List 接口-Java快速入门教程
List Interface
Java 中的List是用于按顺序存储元素的集合。顺序表示第一个元素，接着是第二个元素，然后是第三个元素，依此类推。
Java 列表是 java.util 包中可用的集合接口的子接口。子接口是指扩展另一个接口的接口称为子接口。在这里，列表接口扩展了集合接口。
java 中列表接口的一般声明如下：
public interface List<E> extends Collection<E>
它是一个有序集合，其中元素由索引位置维护，因为它使用基于索引的结构。在List接口中，它保留我们添加元素的顺序。在检索元素时，我们还将获得相同的序列。
它用于存储允许重复元素的元素集合。
Java 中的List接口有四个具体的子类。它们是 ArrayList、LinkedList、Vector 和 Stack。这四个子类实现List接口。
ArrayList和LinkedList在Java程序中广泛用于创建List。Vector 类自 JDK 5 起已弃用。
Java 中列表接口的功能
java中的List具有以下功能。它们如下：
1. List允许存储重复的元素。JVM通过使用“索引”来区分重复元素。索引是指某个对象在数组中的位置。它总是从零开始。
例如，假设有一个大小为 10 的List。假设第一个元素在零索引位置是“a”，第二个元素也是位于第 9 个位置的“a”。因此，List中有两个“a”元素分别位于位置 0 和 9。
因此，JVM 将根据索引的数字位置来区分List中的两个元素。因此，索引非常有用，对区分对象起着重要作用。
2.在List中，我们可以在任何位置添加一个元素。
3. 保持插入顺序。即List可以使用索引保留插入顺序。
4.它允许存储许多空元素。
5. Java List使用可调整大小的数组来实现。可调整大小意味着我们可以增加或减少数组的大小。
6. 除了 LinkedList 之外，ArrayList 和 Vector 是基于索引的结构。
7. 它提供了一个称为ListIterator的特殊迭代器，允许使用hasNext()和next()方法向前访问元素。在相反的方向上，它使用hasPrevious()和previous()方法访问元素。我们可以添加、删除集合中的元素，也可以使用ListIterator将现有元素替换为新元素。
如何在Java中创建List？
要在java中创建一个List，我们可以使用它的两个具体子类之一:ArrayList和LinkedList。我们将使用ArrayList创建一个List，并在程序部分中使用list接口提供的测试方法。
List p = new ArrayList(); List q = new LinkedList(); List r = new Vector(); List s = new Stack();
如何在 Java 中创建泛型List对象
在 Java 1.5 中引入泛型之后，我们可以限制可以存储在List中的对象类型。使用泛型类型参数创建对象列表的一般语法如下：
1. List<data type> list = new ArrayList<data type>(); // General sysntax. For example: a. List<String> list = new ArrayList<String>();
// Creating a list of objects of String type using ArrayList. b. List<Integer> list = new LinkedList<Integer>(); Creating a list of objects of Integer type using LinkedList. c. List<String> list1 = new LinkedList<String>(); d. List<obj> list = new ArrayList<obj>(); // obj is the type of object. For example: List<Book> list=new ArrayList<Book>(); // Book is the type of object. 2. Starting from Java 1.7, we can use a diamond operator. a. List<String> str = new ArrayList<>(); b. List<Integer> list = new LinkedList<>();
List 初始化
创建List后，我们需要通过向其添加元素来初始化列表。有三种方法可以初始化列表。它们如下：
- 使用 Arrays.asList
- 使用正常方式
- 使用匿名内部类
List 方法
List 接口为其扩展的collection 接口指定的 15 个方法中提供了 10 个特定且有用的方法。这些方法可用于在 java 中初始化List。它们如下：
1. boolean add(Object o): 它从零位置开始添加指定的元素。如果元素已经存在于零位置，它将在下一个位置添加下一个元素。
例如，考虑上图中的 1。
list.add("a"); // Here, list is object reference variable.
list.add("b");
add（） 方法的返回类型是布尔值，输入类型是对象。
2. void add（int index， Object o）：此方法在列表中的特定位置添加/插入指定的元素。例如，假设我们想在第 3 个位置添加元素 “d”，我们将调用 add（int index， Object o ） 方法，如下所示：
list.add(3,"d"); // It will add element "d" at 3rd position as shown in figure.
3. boolean addAll(Collection c): 在这里，集合 c 表示一组元素。此方法用于在最后一个元素的末尾添加/插入一组元素。
例如，假设我们要在列表中的位置 0、1 和 2 分别添加三个元素 x、y 和 z。
list.add("x");
list.add("y");
list.add("z");
现在我们将创建一个包含另一组元素的列表，如下所示：
list1.add("a");
list1.add("b");
list1.add("c");
list.addAll(list1); // It will add group of elements at the end of the last element in the list.
The last element is z. So, after z, it will add list1 as shown in above figure.
4.boolean addAll(int index, Collection c): 此方法用于在列表中的特定位置添加/插入一组元素，并通过增加索引将后续元素向右移动。
例如，假设我们想使用 list1 引用变量在列表中分别在位置 1、2 和 3 添加三个元素。
list1.add("A");
list1.add("B");
list1.add("C");
现在我们将使用 list2 引用变量创建另一组元素的列表。
list2.add("G");
list2.add("H");
假设我们要在 list1 的位置 2 添加这组元素。因此，我们将调用addAll（int index，Collection c）方法，如下所示：
// You will see that element C is shifted to right at position 4 。
list1.addAll(2, list2);
5. object remove(int index): 用于删除列表中指定位置的元素。
//It will remove the element at 2nd position and element D which is at 3rd position,
//will be shifted to the left at the 2nd position. The output will be A, B, D.
list1.remove(2);
6. object get(int index): 此方法用于返回存储在列表中指定位置的元素/对象。get（） 方法的返回类型是 Object，输入类型是 int[List 的索引]。
例如：
list1.get(2); // Output will be 'C'.
7. int indexOf（Object o）：用于返回列表中第一次出现的特定元素的索引。如果该元素不在列表中，则它将返回 -1。它以查找的元素对象作为参数，若找到则返回此元素在列表中的索引值。
例如，假设元素“A”存在于列表中的位置 0，另有一个值相同的元素也存在于列表中的第9位置 。
// It will return integer value of an element "A" of first occurrence.
// i.e from zero position, not from position 9. So the output is 0.
list.indexOf("A");
8. int lastIndexOf（Object o）：它返回列表中指定元素最后一次出现的索引。如果列表不包含该特定元素，它将返回 -1。
例如：
list.lastIndexOf("A"); // Output will be 9.
9. object set(int index, Object o): 此方法将列表中指定位置的现有元素替换为新的指定元素。
例如：
list1.set(2, "Z");
10. ListIterator listIterator（）：它以正确的顺序返回列表中元素的列表迭代器。
11. ListIterator listIterator（int）：此方法从列表中的指定位置开始，以正确的顺序返回列表中元素的列表迭代器。
List 示例程序
让我们基于上述所有方法采取不同类型值的展示例程序来帮助大家更好地理解List 。
让我们先创建一个整型与字符串类型数据的示例程序，我们将在其中将整数和字符串元素相加。在这个程序中我们不会使用泛型。
程序源代码 1：
package listPrograms;
import java.util.ArrayList;
import java.util.List;
public class AddEx
{
public static void main(String[] args)
{
// Create a List.
// Here, there is no use of generic. So, no type safety. We can add both integer and string elements.
List al = new ArrayList();
// Adding elements using add() method with reference variable
al.add(10);
al.add(20);
al.add(30);
al.add(40);
al.add("Shubh");
// Adding element to 4th position.
al.add(4, 35);
// Adding element to 5th position.
al.add(5, 45);
System.out.println("Elements after adding: " +al);
}
}
Output:
Elements after adding: [10, 20, 30, 40, 35, 45, Shubh]
让我们创建一个程序，我们将在其中创建一个list1 和另一个list2。我们将list 2 的元素添加到list 1 的位置 2 中。查看源代码以更好地理解。
程序源代码 2：
package listPrograms;
import java.util.ArrayList;
import java.util.List;
public class AddAllEx
{
public static void main(String[] args)
{
// Create a list1 of only String type. This means that Compiler will give errors if we try to put any elements other than String type.
List<String> al = new ArrayList<String>();
al.add("Apple");
al.add("Mango");
al.add("Orange");
al.add("Grapes");
System.out.println("List1 contain: " +al);
// Create another List2 of String type.
List<String> al2 = new ArrayList<String>();
al2.add("11");
al2.add("12");
al2.add("13");
System.out.println("List2 contain :-"+al2);
// Adding List2 in List1 at 2nd position(i.e index=2) using addAll() method.
al.addAll(2, al2);
System.out.println("List1 after adding List2 at 2nd position :-"+al);
}
}
Output:
List1 contain: [Apple, Mango, Orange, Grapes]
List2 contain: [11, 12, 13]
List1 after adding List2 at 2nd position: [Apple, Mango, 11, 12, 13, Orange, Grapes]
程序源代码 3：
package listPrograms;
import java.util.ArrayList;
import java.util.List;
public class IndexOfEx
{
public static void main(String[] args)
{
List al = new ArrayList();
al.add("AA");
al.add("BB");
al.add("CC");
al.add("DD");
al.add("EE");
al.add("FF");
// To find the Index of any particular element, use obj.indexOf(object o) method.
System.out.println("Index of CC: "+al.indexOf("CC"));
System.out.println("Index of FF: "+al.indexOf("FF"));
}
}
Output:
Index of CC: 2
Index of FF: 5
程序源代码 4：
package listPrograms;
import java.util.ArrayList;
import java.util.List;
public class GetMethodEx
{
public static void main(String[] args)
{
List al = new ArrayList();
// Adding Element using reference variable al.
al.add("pen");
al.add("pencil");
al.add("ink");
al.add("notebook");
al.add("book");
al.add("paper");
// Now call get(int index) method to get elements from specified index and print them.
System.out.println("First Element: " +al.get(0));
System.out.println("Fourth Element: " +al.get(3));
}
}
Output:
First Element: pen
Fourth Element: notebook
Java List vs ArrayList
List 是一个接口，而 ArrayList 是实现 List 接口的实现类。
何时使用列表？
在 java 应用程序中使用列表时应牢记以下几点。它们是：
1.当我们想要允许或存储重复元素时，可以使用列表。
2.当我们想要存储空元素时可以使用它。
3.当我们想保留我的插入顺序时，我们应该选择列表。
