List

Java List 集合详解

List 是 Java 集合框架中的一个接口，继承自 Collection，允许存储重复元素，并且保持元素的插入顺序。它是有序的，并提供了基于索引的操作，可以随时访问、插入或删除元素。

---

✅ 1. List 的特点

• 有序性：List 保证元素的存储顺序与插入顺序相同。
• 允许重复元素：List 允许多个元素具有相同的值。
• 索引访问：可以使用 get(int index) 通过索引访问元素。
• 支持 null 值：可以存储 null。

---

✅ 2. List 的主要实现类

实现类	底层数据结构	特点
ArrayList	动态数组	读取快，增删慢（基于数组）
LinkedList	双向链表	增删快，读取慢（基于链表）
Vector	动态数组（线程安全）	线程安全，但性能较低
Stack	栈（继承 Vector）	先进后出（LIFO）

---

✅ 3. List 的常用方法

List 继承了 Collection 的方法，并额外提供了一些基于索引的操作方法：

方法	作用
add(E e)	添加元素
add(int index, E element)	在指定位置插入元素
remove(int index)	根据索引删除元素
remove(Object o)	删除匹配的第一个元素
set(int index, E element)	修改指定索引位置的元素
get(int index)	获取指定索引的元素
indexOf(Object o)	返回元素的索引（首次出现）
lastIndexOf(Object o)	返回元素的索引（最后出现）
subList(int fromIndex, int toIndex)	获取子列表
sort(Comparator<? super E> c)	对 List 进行排序
replaceAll(UnaryOperator<E> operator)	替换所有元素

---

✅ 4. ArrayList 用法

4.1 创建 ArrayList

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

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        
        // 添加元素
        list.add("Java");
        list.add("Python");
        list.add("C++");

        System.out.println(list); // [Java, Python, C++]
    }
}

---

4.2 按索引操作

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

public class ArrayListIndexExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // 通过索引访问元素
        System.out.println(list.get(1)); // Python

        // 修改元素
        list.set(1, "JavaScript");
        System.out.println(list); // [Java, JavaScript, C++]

        // 删除元素
        list.remove(2);
        System.out.println(list); // [Java, JavaScript]
    }
}

---

4.3 遍历 ArrayList

方式 1：普通 for 循环

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

方式 2：增强 for 循环

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

方式 3：Iterator 遍历

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

public class IteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

方式 4：Lambda 表达式

list.forEach(System.out::println);

---

4.4 排序 ArrayList

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

public class ListSortExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(2);
        list.add(8);
        list.add(1);

        // 升序排序
        Collections.sort(list);
        System.out.println(list); // [1, 2, 5, 8]

        // 降序排序
        list.sort(Collections.reverseOrder());
        System.out.println(list); // [8, 5, 2, 1]
    }
}

---

✅ 5. LinkedList 用法

LinkedList 适用于频繁的插入和删除操作。

5.1 LinkedList 特性

• 基于双向链表，插入/删除操作比 ArrayList 更快。
• 适用于队列（FIFO）和栈（LIFO）结构。
• 支持头尾操作（addFirst()、addLast()、removeFirst()、removeLast()）。

5.2 LinkedList 示例

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

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // 头部插入
        ((LinkedList<String>) list).addFirst("Go");
        // 尾部插入
        ((LinkedList<String>) list).addLast("Rust");

        System.out.println(list); // [Go, Java, Python, C++, Rust]

        // 删除头部和尾部元素
        ((LinkedList<String>) list).removeFirst();
        ((LinkedList<String>) list).removeLast();
        System.out.println(list); // [Java, Python, C++]
    }
}

---

✅ 6. Vector 和 Stack

6.1 Vector（线程安全的 ArrayList）

Vector 和 ArrayList 类似，但它的方法是 线程安全 的（使用 synchronized 进行同步）。

import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("Java");
        vector.add("Python");
        vector.add("C++");

        System.out.println(vector); // [Java, Python, C++]
    }
}

6.2 Stack（栈，先进后出）

Stack 继承 Vector，是一个**后进先出（LIFO）**的集合，常用方法：

• push(E e)：压栈
• pop()：弹栈
• peek()：查看栈顶元素

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.push("Java");
        stack.push("Python");
        stack.push("C++");

        System.out.println(stack.pop()); // C++
        System.out.println(stack.peek()); // Python
    }
}

---

✅ 7. 总结

• ArrayList：查询快，增删慢，适用于读多写少的场景。
• LinkedList：增删快，查询慢，适用于频繁插入删除的场景。
• Vector：线程安全，但性能较低。
• Stack：后进先出（LIFO）。