Java 复习笔记 - 集合进阶篇：List集合

---

List 集合 概述

在Java中，List是一种集合接口，它继承自Collection接口。List代表一个有序的元素集合，其中每个元素都有其特定的位置，即索引。List接口的主要实现类包括ArrayList、LinkedList等。

List接口提供了大量的方法来操作集合中的元素，包括添加、删除、获取元素等。其中，add(int index, E element)方法可以在指定位置插入元素；remove(int index)方法可以删除指定位置的元素；get(int index)方法可以获取指定位置的元素。

List集合还支持一些高级操作，如列表迭代、列表反转、列表排序等。例如，可以使用for-each循环遍历List集合中的元素；使用Collections.reverse(List list)方法反转List集合中的元素；使用Collections.sort(List list)方法对List集合中的元素进行排序。

需要注意的是，List集合中的元素可以重复，也就是说，可以存储多个相同的对象。同时，List集合中的元素可以是任何对象，包括基本类型、自定义对象等。

List 集合特有的方法

以上是List集合特有的方法，使用这些方法可以方便地操作List集合中的元素，实现集合的管理和操作。

4种频繁使用方法的讲解

（一）add()

List集合中的add()方法用于向集合中添加元素。它有两种形式：

1. add(E e)：将指定的元素追加到此列表的末尾。
2. add(int index, E element)：将指定的元素插入此列表中的指定位置。

示例代码如下：

import java.util.ArrayList;
import java.util.List;

public class ListAddExample {
    public static void main(String[] args) {
        // 创建一个ArrayList集合对象
        List<String> list = new ArrayList<>();

        // 使用add()方法向集合中添加元素
        list.add("苹果");
        list.add("香蕉");
        list.add("橙子");

        // 使用add(int index, E element)方法向指定位置插入元素
        list.add(1, "葡萄");

        // 打印集合中的元素
        System.out.println(list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

上述代码中，首先创建了一个ArrayList集合对象list，然后使用add()方法向集合中添加了三个元素。接着使用add(int index, E element)方法向指定位置插入了一个元素。最后打印集合中的元素，输出结果如下：

[苹果, 葡萄, 香蕉, 橙子]
1

（二）remove()

List集合中的remove()方法用于删除集合中的元素。它有两种形式：

1. remove(Object o)：从列表中删除首次出现的指定元素（如果存在）。
2. remove(int index)：删除指定下标的元素。

示例代码如下：

import java.util.ArrayList;
import java.util.List;

public class ListRemoveExample {
    public static void main(String[] args) {
        // 创建一个ArrayList集合对象
        List<String> list = new ArrayList<>();

        // 使用add()方法向集合中添加元素
        list.add("苹果");
        list.add("香蕉");
        list.add("橙子");

        // 使用remove()方法删除集合中的元素
        list.remove("香蕉");
        list.remove(1);

        // 打印集合中的元素
        System.out.println(list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

上述代码中，首先创建了一个ArrayList集合对象list，然后使用add()方法向集合中添加了三个元素。接着使用remove()方法删除了集合中指定元素和下标位置的元素。最后打印集合中的元素，输出结果如下：

[苹果, 橙子]
1

（三）set()

List集合中的set()方法用于将指定下标位置的元素替换为新元素。它有两种形式：

1. set(int index, E element)：用指定的元素替换此列表中指定位置的元素。
2. set(int fromIndex, int toIndex, List list)：将指定列表中的元素替换为指定列表中的元素。

示例代码如下：

import java.util.ArrayList;
import java.util.List;

public class ListSetExample {
    public static void main(String[] args) {
        // 创建一个ArrayList集合对象
        List<String> list = new ArrayList<>();

        // 使用add()方法向集合中添加元素
        list.add("苹果");
        list.add("香蕉");
        list.add("橙子");

        // 使用set()方法替换集合中的元素
        list.set(1, "葡萄");
        List<String> newList = new ArrayList<>();
        newList.add("西瓜");
        newList.add("草莓");
        list.set(2, 4, newList);

        // 打印集合中的元素
        System.out.println(list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

上述代码中，首先创建了一个ArrayList集合对象list，然后使用add()方法向集合中添加了三个元素。接着使用set()方法替换了集合中指定下标位置的元素和指定范围内的元素。最后打印集合中的元素，输出结果如下：

[苹果, 葡萄, 西瓜, 草莓]
1

（四）get()

List集合中的get()方法用于获取指定下标位置的元素。它有两种形式：

1. get(int index)：获取指定下标的元素。
2. get(int fromIndex, int toIndex)：获取指定范围内的元素列表。

示例代码如下：

import java.util.ArrayList;
import java.util.List;

public class ListGetExample {
    public static void main(String[] args) {
        // 创建一个ArrayList集合对象
        List<String> list = new ArrayList<>();

        // 使用add()方法向集合中添加元素
        list.add("苹果");
        list.add("香蕉");
        list.add("橙子");

        // 使用get()方法获取集合中的元素
        String element = list.get(1);
        List<String> subList = list.subList(1, 3);

        // 打印获取到的元素和子列表
        System.out.println("获取到的元素：" + element);
        System.out.println("获取到的子列表：" + subList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

上述代码中，首先创建了一个ArrayList集合对象list，然后使用add()方法向集合中添加了三个元素。接着使用get()方法获取了集合中指定下标位置的元素和指定范围内的元素列表。最后打印获取到的元素和子列表，输出结果如下：

获取到的元素：香蕉
获取到的子列表：[香蕉, 橙子]
1
2

List 集合的5种遍历方式

（一）迭代器

Java中的List集合是一种有序的集合，可以包含重复的元素。List集合提供了多种方法来访问和修改其中的元素，其中包括使用迭代器进行遍历。

迭代器是一种用于遍历集合对象的工具，它允许程序员依次访问集合中的每个元素，而不需要了解底层实现。Java中的List集合提供了iterator()方法来获取一个迭代器对象，通过该迭代器对象可以遍历List集合中的元素。

以下是使用迭代器遍历List集合的示例代码：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // 创建一个 List 集合
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        // 获取 List 集合的迭代器
        Iterator<String> iterator = list.iterator();

        // 遍历 List 集合中的元素
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个示例中，首先创建了一个包含三个元素的ArrayList集合。然后，使用iterator()方法获取了该集合的迭代器对象。通过使用while循环和迭代器的hasNext()方法，可以依次访问集合中的每个元素，并使用next()方法获取当前元素的值。最后，将每个元素打印到控制台上。

（二）列表迭代器

Java中的List集合提供了一种列表迭代器（ListIterator），它允许程序员在遍历集合的同时修改其中的元素。列表迭代器具有指向当前元素的指针，因此可以通过调用next()方法来依次访问集合中的每个元素，并且可以通过调用add()方法来在当前位置插入新元素，通过调用remove()方法来删除当前位置的元素。

以下是使用列表迭代器遍历List集合的示例代码：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListExample {
    public static void main(String[] args) {
        // 创建一个 List 集合
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        // 获取 List 集合的列表迭代器
        ListIterator<String> iterator = list.listIterator();

        // 遍历 List 集合中的元素
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个示例中，首先创建了一个包含三个元素的ArrayList集合。然后，使用listIterator()方法获取了该集合的列表迭代器对象。通过使用while循环和迭代器的hasNext()方法，可以依次访问集合中的每个元素，并使用next()方法获取当前元素的值。最后，将每个元素打印到控制台上。

（三）增强for

Java中的增强for循环（也称为for-each循环）是一种用于遍历集合或数组的语法结构。它允许程序员以更简单、更直观的方式遍历集合中的元素，而不需要使用迭代器或索引。

以下是使用增强for循环遍历List集合的示例代码：

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // 创建一个 List 集合
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        // 使用增强for循环遍历 List 集合中的元素
        for (String element : list) {
            System.out.println(element);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个示例中，首先创建了一个包含三个元素的ArrayList集合。然后，使用增强for循环遍历该集合中的元素，并将每个元素打印到控制台上。

增强for循环的语法结构如下：

for (元素类型 变量名 : 集合或数组) {
    // 循环体语句
}
1
2
3

其中，元素类型是集合或数组中元素的类型，变量名是一个用于引用当前元素的变量名。在每次循环中，变量将被赋值为集合或数组中的下一个元素，直到所有元素都被遍历完毕。在循环体中，程序员可以使用该变量来访问当前元素。

（四）Lambda 表达式

Java中的Lambda表达式是一种匿名函数，可以作为参数传递给方法或存储在变量中。在Java 8及更高版本中，Lambda表达式可以用于遍历List集合中的元素，并执行特定的操作。

以下是使用Lambda表达式遍历List集合的示例代码：

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // 创建一个 List 集合
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        // 使用 Lambda 表达式遍历 List 集合中的元素
        list.forEach(element -> System.out.println(element));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这个示例中，首先创建了一个包含三个元素的ArrayList集合。然后，使用forEach()方法和Lambda表达式遍历该集合中的元素，并将每个元素打印到控制台上。Lambda表达式“element -> System.out.println(element)”作为参数传递给forEach()方法，它接受一个Consumer函数式接口的实例作为参数，该接口定义了一个可以接受一个参数并且不返回任何值的方法。在这种情况下，Lambda表达式将接受一个String类型的参数，并将其打印到控制台上。

使用Lambda表达式遍历List集合可以使代码更加简洁和易于阅读。

（五）普通for循环

Java中的List集合是一种有序的集合，可以包含重复的元素。List集合提供了多种方法来访问和修改其中的元素，其中包括使用普通for循环进行遍历。

以下是使用普通for循环遍历List集合的示例代码：

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // 创建一个 List 集合
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        // 使用普通for循环遍历 List 集合中的元素
        for (int i = 0; i < list.size(); i++) {
            String element = list.get(i);
            System.out.println(element);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这个示例中，首先创建了一个包含三个元素的ArrayList集合。然后，使用普通for循环遍历该集合中的元素。循环从0开始，直到集合的大小减1，每次迭代获取当前索引处的元素，并将其打印到控制台上。

使用普通for循环遍历List集合是一种简单的方法，但在某些情况下可能不够灵活，例如需要在遍历过程中删除元素时。在这种情况下，建议使用迭代器或增强for循环进行遍历。