Java集合List接口

List接口介绍

Java List接口java.util.List表示对象的有序序列。 Java列表中包含的元素可以根据在Java列表中内部出现的顺序进行插入，访问，迭代和删除。 元素的顺序就是为什么此数据结构称为列表的原因。

Java列表中的每个元素都有一个索引。 列表中的第一个元素的索引为0，第二个元素的索引为1，依此类推。索引的意思是“离列表开头还有多少个元素”。 因此，第一个元素离列表的开头有0个元素-因为它位于列表的开头。

您可以将任何Java对象添加到列表中。如果未使用Java泛型键入列表，则您甚至可以在同一列表中混合使用不同类型（类）的对象。但是，实际上，通常不会在同一List中混合不同类型的对象。

Java List接口是标准Java接口，它是Java Collection接口的子类型，这意味着List继承自Collection。

List接口与Set接口对比

Java List和Java Set接口非常相似，因为它们都表示元素的集合。 但是，有一些显着差异。

Java List和Java Set接口之间的第一个区别是，同一元素在Java List中可以出现多次。 这不同于JavaSet，在JavaSet中,每个元素只能出现一次。

Java List和Java Set接口之间的第二个区别是，List中的元素具有顺序，并且可以按照该顺序进行迭代。 JavaSet不对内部保留的元素的顺序作出任何保证。

List实现类

作为Collection子类型，Collection接口中的所有方法也可以在List接口中使用。

由于List是一个接口，因此您需要实例化该接口的具体实现才能使用它。 您可以在Java Collections API的以下列表的实现中进行选择：

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack 在这些实现中，ArrayList是最常用的。

java.util.concurrent包中还有并发List实现

创建一个列表

You create a List instance by creating an instance of one of the classes that implements the List interface.

        List list = new ArrayList();
        List list1 = new LinkedList();
        List list2 = new Vector();
        List list3 = new Stack();

请记住，大多数情况下，您将使用ArrayList类，但是在某些情况下，使用其他实现之一可能是有意义的。

泛型List

By default you can put any Object into a List, but from Java 5, Java Generics makes it possible to limit the types of object you can insert into a List. Here is an example:

List<Animal> list = new ArrayList<>();

This List can now only have MyObject instances inserted into it. You can then access and iterate its elements without casting them. Here is how it looks:
Person.java

package Bean;

public class Person {

    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Test.java

        List<Person> list = new ArrayList<>();

        Person person = new Person("zhandonghong", 25);
        Person person1 = new Person("eason", 45);


        list.add(person);
        list.add(person1);

        for (Person person2 : list) {
            System.out.println("Name:" + person2.name + ",Age:" + person2.age);
        }

在Java列表中插入元素

您可以使用其add（）方法将元素（对象）插入Java列表

        List<String> list1 = new ArrayList<>();
        list1.add("element1");
        list1.add("element2");
        list1.add("element3");

        list1.forEach(e -> System.out.println(e));

向列表中插入空值

实际上可以在Java列表中插入空值

        List<Person> list = new ArrayList<>();

        Person person = new Person("zhandonghong", 25);
        Person person1 = new Person("eason", 45);


        list.add(person);
        list.add(person1);

        Object element = null;
//      list允许插入null
        list.add((Person) element);

在特定索引处插入元素

可以在特定索引处将元素插入Java列表。 List接口具有一个add（）方法的版本，该版本是将索引作为第一个参数，并将要插入的元素作为第二个参数
需要注意，当插入的时候，索引位置应该在已有的索引范围之内

        List<String> list1 = new ArrayList<>();
        list1.add("element1");
        list1.add("element2");
        list1.add("element3");

        list1.add(2, "elementindex2");

        list1.forEach(e -> System.out.println(e));

插入的位置如果已经有元素了，那么该元素的索引就会往后移动一位

将一个列表中的所有元素插入到另一个列表中

可以将一个Java列表中的所有元素添加到另一个列表中。 您可以使用List addAll（）方法执行此操作。 结果列表是两个列表的并集。

        List<String> list1 = new ArrayList<>();
        list1.add("element1");
        list1.add("element2");
        list1.add("element3");

        list1.add(2, "elementindex2");

        List<String> list2 = new ArrayList<>();
        list2.add("index1");
        list2.add("index2");
        list2.add("index3");
        list2.add("index4");

        list1.addAll(list2);

        list1.forEach(e -> System.out.println(e));

从Java列表中获取元素

您可以使用元素索引从Java列表中获取元素。 您可以使用get（int index）方法执行此操作

        List<String> list1 = new ArrayList<>();
        list1.add("element1");
        list1.add("element2");
        list1.add("element3");

        list1.add(2, "elementindex2");

        List<String> list2 = new ArrayList<>();
        list2.add("index1");
        list2.add("index2");
        list2.add("index3");
        list2.add("index4");

        list1.addAll(list2);

        System.out.println(list1.get(0));

在列表中查找元素的位置索引

根据值找位置

You can find elements in a Java List using one of these two methods:

• indexOf方法在给定元素的列表中查找第一个匹配项的索引
• lastIndexOf方法在给定元素的列表中查找最后一次出现的索引。

        List<String> list1 = new ArrayList<>();
        list1.add("element1");
        list1.add("element2");
        list1.add("element3");

        list1.add(2, "elementindex2");
        list1.add("element3");

        List<String> list2 = new ArrayList<>();
        list2.add("index1");
        list2.add("index2");
        list2.add("index3");
        list2.add("index4");

        list1.addAll(list2);

        System.out.println(list1.indexOf("element3"));
        System.out.println(list1.lastIndexOf("element3"));
        System.out.println(list1.indexOf("elementindex2"));

检查列表是否包含元素

You can check if a Java List contains a given element using the List contains() method.

  System.out.println(list1.contains("element1"));

检查列表是否包含null

        list1.add(null);
        boolean containsElement = list1.contains(null);
        System.out.println(containsElement);

从Java列表中删除元素

您可以通过以下两种方法从Java列表中删除元素：
remove(Object element)
remove(int index)

remove（Object element）删除列表中的该元素（如果参数中的元素存在）。 然后，列表中的所有后续元素将在列表中上移。 因此，它们的索引减少1

List remove（int index）方法删除给定索引处的元素。 然后，列表中的所有后续元素将在列表中上移。 因此，它们的索引减少1。

        List<String> list1 = new ArrayList<>();
        list1.add("element1");
        list1.add("element2");
        list1.add("element3");

        list1.add(2, "elementindex2");
        list1.add("element3");

        List<String> list2 = new ArrayList<>();
        list2.add("index1");
        list2.add("index2");
        list2.add("index3");
        list2.add("index4");

        list1.addAll(list2);

        System.out.println(list1.size());
        list1.remove(0);
        list1.remove("element3");
        System.out.println(list1.size());

从Java列表中删除所有元素

Java List接口包含一个clear（）方法，该方法在调用时从列表中删除所有元素。 从列表中删除所有元素也称为清除列表

        list1.clear();
        System.out.println(list1.size());

Retain All Elements From One List in Another

Java列表接口有一个名为retainal（）的方法，它能够保留一个列表中的所有元素，这些元素也存在于另一个列表中。换句话说，retain（）方法从目标列表中删除在其他列表中找不到的所有元素。结果列表是两个列表的交集。

        List<String> list = new ArrayList<>();
        List<String> otherList = new ArrayList<>();

        String element1 = "element 1";
        String element2 = "element 2";
        String element3 = "element 3";
        String element4 = "element 4";

        list.add(element1);
        list.add(element2);
        list.add(element3);

        otherList.add(element1);
        otherList.add(element3);
        otherList.add(element4);

        list.retainAll(otherList);

        list.forEach(e -> System.out.println(e));

List大小

您可以通过调用size（）方法获得List中的元素数量。

        list.forEach(e -> System.out.println(e));

子列表

Java List接口具有一个名为subList（）的方法，该方法可以使用原始List中的元素的子集创建一个新List。

        List<String> list = new ArrayList<>();

        list.add("element 1");
        list.add("element 2");
        list.add("element 3");
        list.add("element 4");

        List<String> sublist = list.subList(1, 3);

        sublist.forEach(e -> System.out.println(e));

将列表（List）转换为集合（Set）

通过创建一个新的Set并将列表中的所有元素添加到其中，可以将Java List转换为Java Set。 该集合将删除所有重复项。 因此，结果集将包含列表中的所有元素，但仅包含一次

        List<String> list = new ArrayList<>();

        list.add("element 1");
        list.add("element 2");
        list.add("element 3");
        list.add("element 3");

        Set<String> set = new HashSet<>();
        set.addAll(list);

        set.forEach(e -> System.out.println(e));

将列表(List )转换为数组(Array)

您可以使用List toArray（）方法将Java List转换为Java Array。

        List<String> list = new ArrayList<>();

        list.add("element 1");
        list.add("element 2");
        list.add("element 3");
        list.add("element 3");
        
        Object[] objects = list.toArray();

也可以将List转换为特定类型的数组

        String[] strings = list.toArray(new String[0]);

Note that even if we pass a String array of size 0 to the toArray(), the array returned will have all the elements in the List in it. It will have the same number of elements as the List.

将数组转换为列表

        String[] values = new String[]{"one", "two", "three"};
        List<String> strings = Arrays.asList(values);

        for (String string : strings) {
            System.out.println(string);
        }

可比较对象的列表排序

If the List contains objects that implement the Comparable interface (java.lang.Comparable), then the objects can compare themselves to each other. In that case you can sort the List like this:

        List<String> list = new ArrayList<>();

        list.add("c");
        list.add("b");
        list.add("a");

        Collections.sort(list);

        list.forEach(e -> System.out.println(e));

//        result:
//        a
//        b
//        c

The Java String class implements the Comparable interface, you can sort them in their natural order, using the Collections sort() method.

Sort List Using Comparator

        List<Car> list = new ArrayList<>();

        list.add(new Car("Volvo V40", "XYZ 201845", 5));
        list.add(new Car("Citroen C1", "ABC 164521", 4));
        list.add(new Car("Dodge Ram", "KLM 845990", 2));

        Comparator<Car> carBrandComparator = new Comparator<Car>() {
            @Override
            public int compare(Car o1, Car o2) {
                return o1.brand.compareTo(o2.brand);
            }
        };

        Collections.sort(list, carBrandComparator);

        list.forEach((e) -> {
            System.out.println(e.brand + "," + e.numberPlate + "," + e.noOfDoors);
        });
        
//        result:
//        Citroen C1,ABC 164521,4
//        Dodge Ram,KLM 845990,2
//        Volvo V40,XYZ 201845,5

Notice the Comparator implementation in the example above. This implementation only compares the brand field of the Car objects.

迭代列表

Collection和迭代器接口都已经介绍了这个部分的三种迭代方式，这里不再重复

• 迭代器迭代元素
• “for each” loop
• standard for loop（标准 for循环）
• lambda表达式迭代