Java `List` 接口详细教学

java.util.List 是 Java 集合框架中的一个接口，继承自 Collection，表示一个有序、可重复的元素集合。

1. `List` 特点

有序（Ordered）：元素存储顺序与插入顺序一致。
可重复（Duplicates Allowed）：允许存储重复元素。
支持索引（Index-based）：可以通过索引访问和修改元素。
支持任意位置插入/删除（Insert/Delete at any position）。
允许存储 null 值。

2. `List` 主要实现类

实现类	特点
`ArrayList`	基于动态数组，查询快（`O(1)`），增删慢（`O(n)`），线程不安全。
`LinkedList`	基于双向链表，增删快（`O(1)`），查询慢（`O(n)`），线程不安全。
`Vector`	线程安全的 `ArrayList`，但性能较低。
`Stack`	继承 `Vector`，实现 LIFO 结构（栈）。

3. `List` 的常用方法

List 继承自 Collection，所以它除了支持 Collection 的方法外，还有基于索引的额外方法。

方法	说明
`add(E e)`	添加元素到末尾
`add(int index, E e)`	在指定索引插入元素
`get(int index)`	获取指定索引的元素
`set(int index, E e)`	修改指定索引的元素
`remove(int index)`	删除指定索引的元素
`remove(Object o)`	删除指定对象（如果存在多个，只删除第一个）
`indexOf(Object o)`	返回对象的首次出现索引
`lastIndexOf(Object o)`	返回对象的最后出现索引
`contains(Object o)`	是否包含指定元素
`size()`	返回列表大小
`isEmpty()`	是否为空
`clear()`	清空列表
`subList(int fromIndex, int toIndex)`	截取子列表

4. `ArrayList` 示例

ArrayList 是 List 最常用的实现，基于动态数组，查询快，适合查询多、插入少的场景。

基本操作

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

public class ArrayListExample {
    public static void main(String[] args) {
        // 创建 ArrayList
        List<String> list = new ArrayList<>();

        // 添加元素
        list.add("Java");
        list.add("Python");
        list.add("C++");
        list.add("Java");

        System.out.println("列表内容: " + list);  // 输出: [Java, Python, C++, Java]

        // 获取元素
        System.out.println("索引 1 处的元素: " + list.get(1));  // 输出: Python

        // 修改元素
        list.set(2, "C#");
        System.out.println("修改后: " + list);  // 输出: [Java, Python, C#, Java]

        // 删除元素
        list.remove(3);
        System.out.println("删除元素后: " + list);  // 输出: [Java, Python, C#]

        // 查找元素
        System.out.println("Java 的索引: " + list.indexOf("Java"));  // 输出: 0

        // 检查是否包含
        System.out.println("是否包含 Python? " + list.contains("Python"));  // 输出: true

        // 遍历列表
        System.out.println("遍历列表:");
        for (String item : list) {
            System.out.println(item);
        }
    }
}

输出

列表内容: [Java, Python, C++, Java]
索引 1 处的元素: Python
修改后: [Java, Python, C#, Java]
删除元素后: [Java, Python, C#]
Java 的索引: 0
是否包含 Python? true
遍历列表:
Java
Python
C#

5. `LinkedList` 示例

LinkedList 是基于双向链表的 List 实现，适合增删多、查询少的场景。

LinkedList 额外方法

方法	说明
`addFirst(E e)`	在头部添加元素
`addLast(E e)`	在尾部添加元素
`removeFirst()`	删除并返回头部元素
`removeLast()`	删除并返回尾部元素
`getFirst()`	获取头部元素（不删除）
`getLast()`	获取尾部元素（不删除）

示例

import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();

        list.add("A");
        list.add("B");
        list.add("C");

        System.out.println("LinkedList: " + list);  // 输出: [A, B, C]

        list.addFirst("X");
        list.addLast("Y");

        System.out.println("添加首尾后: " + list);  // 输出: [X, A, B, C, Y]

        System.out.println("首元素: " + list.getFirst());  // 输出: X
        System.out.println("尾元素: " + list.getLast());  // 输出: Y

        list.removeFirst();
        list.removeLast();
        System.out.println("删除首尾后: " + list);  // 输出: [A, B, C]
    }
}

6. `Vector` 示例（线程安全但性能低）

Vector 是 ArrayList 的同步版本，每个方法都有 synchronized 保护，适合多线程场景但性能低。

import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<>();
        vector.add(10);
        vector.add(20);
        vector.add(30);

        System.out.println("Vector: " + vector);
    }
}

7. `Stack` 示例（LIFO 栈）

Stack 继承自 Vector，是**后进先出（LIFO）**结构。

方法	说明
`push(E e)`	入栈
`pop()`	出栈（删除并返回顶部元素）
`peek()`	获取顶部元素（不删除）
`empty()`	是否为空

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();

        stack.push("A");
        stack.push("B");
        stack.push("C");

        System.out.println("栈: " + stack);  // 输出: [A, B, C]

        System.out.println("栈顶元素: " + stack.peek());  // 输出: C
        System.out.println("弹出栈顶: " + stack.pop());  // 输出: C
        System.out.println("弹出后栈: " + stack);  // 输出: [A, B]
    }
}

8. `List` 遍历

方式 1：for-each

1
2
3

for (String item : list) {
    System.out.println(item);
}

方式 2：普通 for 循环

1
2
3

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

方式 3：Lambda 表达式

1	list.forEach(item -> System.out.println(item));

9. 总结

实现类	适用场景
`ArrayList`	读多写少（查询快，增删慢）
`LinkedList`	插入/删除多（增删快，查询慢）
`Vector`	线程安全，但性能低
`Stack`	LIFO 结构

🔥 掌握 List，你就掌握了 Java 集合的核心！ 🚀

Java List 接口详细教学

1. List 特点

2. List 主要实现类

3. List 的常用方法

4. ArrayList 示例