【Java集合框架】04 —— List 接口

一、List 接口 是 什么

Java中的List接口提供了一种存储有序集合的方法，它是Collection的一个子接口。
它是一个有序的对象集合，其中可以存储重复的值。因为List保留了插入顺序，所以它允许位置访问和插入元素。

在java.util包可以找到List接口。并继承Collection接口。 它是一个ListIterator接口工厂。通过ListIterator，我们可以向前和向后迭代列表。List接口的实现类是ArrayList、LinkedList、Stack和Vector。ArrayList和LinkedList在Java编程中被广泛使用
Vector类自Java 5以来已弃用。

二、List 接口 如何创建对象实例

List 接口的声明:

public interface List<E> extends Collection<E> ; 

让我们详细说明如何在List类中创建对象或实例：

• 因为List是一个接口，所以不能按List类型创建对象。我们总是需要一个实现这个List的类来创建对象（如ArrayList）
• 在Java 1.5中引入泛型之后，可以限制可以存储在List中的对象的类型， 就像其他几个由用户定义的“类”实现的用户定义的“接口”一样
• List是一个“接口”，由ArrayList类实现，在java.util 包下

语法：

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

实例：

    public static void main(String[] args) {

        // 创建List接口的对象, 通过 List的实现类： ArrayList
        List<Integer> a1 = new  ArrayList<Integer>();

        // 添加元素
        a1.add(0,1);
        a1.add(1,2);
        
        System.out.println(a1);

        
        List<Integer> a2 = new ArrayList<Integer>();

        a2.add(1);
        a2.add(2);
        a2.add(3);

        // 在 1 索引，添加 a2 List
        a1.addAll(1,a2);

        System.out.println(a1);

        // 去掉 1 索引
        a1.remove(1);
        System.out.println(a1);
        
        //  获取 3 索引 的值
        System.out.println(a1.get(3));

        //  设置 0 索引 的值 为5
        a1.set(0,5);
        System.out.println(a1);
    }

输出：

[1, 2]
[1, 1, 2, 3, 2]
[1, 2, 3, 2]
2
[5, 2, 3, 2]

三、List 接口 的操作

现在让我们使用List 接口执行各种操作，以便更好地理解这些操作。我们将讨论下面列出的操作以及稍后通过干净的java代码实现的操作。

由于List是一个接口，它只能与实现该接口的类一起使用。现在，让我们看看如何对List执行一些常用操作。

• 使用add()方法向List类添加元素
• 使用set()方法更新List类中的元素
• 使用remove()方法删除元素

现在，让我们分别讨论操作，并在代码中实现相同的操作，以便更好地掌握它。

1.添加操作

为了向列表中添加元素，可以使用add()方法。此方法被重载以基于不同参数执行多个操作。

参数:接受2个参数，分别为:

• add(Object):该方法用于在List的末尾添加一个元素。
• add(int index, Object):该方法用于在List的特定索引处添加元素

举例

    public static void main(String[] args) {

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

        // 向 a1 List 添加 元素
        a1.add("广州");
        a1.add("深圳");
        a1.add(1, "上海");

        // 打印输出 a1 对象
        System.out.println(a1);
    }

输出：

[广州, 上海, 深圳]

2. 更新操作

• 添加元素之后，如果我们希望更改元素，可以使用set()方法来完成。
• 因为List是索引的，所以我们想要更改的元素会被该元素的索引所引用。
• 因此，此方法接受一个索引和需要插入到该索引处的更新元素。

    public static void main(String args[]) {
        // 创建List接口的对象, 通过 List的实现类： ArrayList
        List<String> al = new ArrayList<>();

        // 添加元素
        al.add("广州");
        al.add("深圳");
        al.add(1, "上海");

        // 输出添加元素
        System.out.println("Initial ArrayList " + al);

        // 设置 索引1  为 北京
        al.set(1, "北京");

        // 输出更新后的元素
        System.out.println("Updated ArrayList " + al);
    }

输出

添加 ArrayList [广州, 上海, 深圳]
更新 ArrayList [广州, 北京, 深圳]

3. 删除操作

为了从列表中删除一个元素，我们可以使用remove()方法。此方法被重载以基于不同参数执行多个操作

Parameters:

• remove(Object):该方法用于简单地从List中删除一个对象。如果有多个这样的对象，则删除第一个出现的对象。
• remove(int index):由于List被建立了索引，所以这个方法接受一个整数值，它只是简单地删除List中特定索引处的元素。删除元素后，所有元素都向左移动以填充空间，并更新对象的索引。

实例

     // 创建List接口的对象, 通过 List的实现类： ArrayList
        List<String> al = new ArrayList<>();

        // 添加操作
        al.add("广州");
        al.add("深圳");

        // 添加索引为1 的元素
        al.add(1, "上海");

        // 输出 添加后的 List
        System.out.println("添加后 ArrayList " + al);

        // 删除 索引为 1 的元素
        al.remove(1);

        // 输出 删除后的 List
        System.out.println("删除后的LIst" + al);

        // 删除元素 为 上海
        al.remove("深圳");

        // 最后 输出 更新后的 List
        System.out.println("删除后的LIst" + al);

输出

添加后 ArrayList [广州, 上海, 深圳]
删除后的LIst[广州, 深圳]
删除后的LIst[广州]

4. 迭代操作

• 到目前为止，我们的输入规模非常小，我们手动操作每个实体。
• 现在让我们讨论各种方法，通过这些方法，我们可以遍历列表，使它们工作于更大的样本集。

方法：

• 有多种方法可以遍历List。
• 最著名的方法是结合使用基本的for循环和get()方法来获取特定索引处的元素，以及高级的for循环（For-Each）

实例

 // 创建List接口的对象, 通过 List的实现类： ArrayList
        List<String> al = new ArrayList<>();

        // 添加元素
        al.add("广州");
        al.add("深圳");

        // 添加索引 1 的元素
        al.add(1, "上海");

        // 使用for 循环 迭代
        for (int i = 0; i < al.size(); i++) {

            // 使用 get方法  获取元素
            System.out.print(al.get(i) + " ");
        }

        System.out.println("");

        // 使用for-each 循环 迭代
        for (String str : al)

            // 输出元素
            System.out.print(str + " ");

输出

广州 上海 深圳 
广州 上海 深圳 

四、List 接口 的方法

由于不同类型列表背后的主要概念是相同的，列表接口包含以下方法:

boolean add(E e) 
将指定的元素追加到此列表的末尾（可选操作）。  

void add(int index, E element) 
将指定的元素插入此列表中的指定位置（可选操作）。  

boolean addAll(Collection<? extends E> c) 
按指定集合的迭代器（可选操作）返回的顺序将指定集合中的所有元素附加到此列表的末尾。  

boolean addAll(int index, Collection<? extends E> c) 
将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。  

void clear() 
从此列表中删除所有元素（可选操作）。  

boolean contains(Object o) 
如果此列表包含指定的元素，则返回 true 。  

boolean containsAll(Collection<?> c) 
如果此列表包含指定 集合的所有元素，则返回true。  

boolean equals(Object o) 
将指定的对象与此列表进行比较以获得相等性。  

E get(int index) 
返回此列表中指定位置的元素。  

int hashCode() 
返回此列表的哈希码值。  

int indexOf(Object o) 
返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。  

boolean isEmpty() 
如果此列表不包含元素，则返回 true 。  

Iterator<E> iterator() 
以正确的顺序返回该列表中的元素的迭代器。  

int lastIndexOf(Object o) 
返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。  

ListIterator<E> listIterator() 
返回列表中的列表迭代器（按适当的顺序）。  

ListIterator<E> listIterator(int index) 
从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。  

E remove(int index) 
删除该列表中指定位置的元素（可选操作）。  

boolean remove(Object o) 
从列表中删除指定元素的第一个出现（如果存在）（可选操作）。  

boolean removeAll(Collection<?> c) 
从此列表中删除包含在指定集合中的所有元素（可选操作）。  

default void replaceAll(UnaryOperator<E> operator) 
将该列表的每个元素替换为将该运算符应用于该元素的结果。  

boolean retainAll(Collection<?> c) 
仅保留此列表中包含在指定集合中的元素（可选操作）。  

E set(int index, E element) 
用指定的元素（可选操作）替换此列表中指定位置的元素。  

int size() 
返回此列表中的元素数。  

default void sort(Comparator<? super E> c) 
使用随附的 Comparator排序此列表来比较元素。  

default Spliterator<E> spliterator() 
在此列表中的元素上创建一个Spliterator 。  

List<E> subList(int fromIndex, int toIndex) 
返回此列表中指定的 fromIndex （含）和 toIndex之间的视图。  

Object[] toArray() 
以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。  

<T> T[] toArray(T[] a) 
以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。