Java 23 集合框架详解：ArrayList、LinkedList、Vector

news2025/1/8 20:21:54

📚 Java 23 集合框架详解：`ArrayList`、`LinkedList`、`Vector`

在 Java 集合框架中，ArrayList、LinkedList 和 Vector 是三种最常用的 List 接口实现类。它们都可以存储有序的、可重复的元素，但它们在 底层实现、性能和 多线程安全 等方面存在显著差异。

本文将从 使用案例、优化方案 和 多线程优化 等方面详细解析这三种集合的实现原理及适用场景。

📖 1. `ArrayList`、`LinkedList`、`Vector` 概述

集合类型	底层实现	线程安全	性能特点	适用场景
`ArrayList`	动态数组	否	读操作快，增删操作慢	适合读操作频繁的场景
`LinkedList`	双向链表	否	插入/删除操作快，随机访问慢	适合插入/删除操作频繁的场景
`Vector`	动态数组（线程安全）	是	同步开销大，性能较低	适合多线程环境，但不推荐使用

🧩 2. `ArrayList` 详解

✅ 2.1 特点

基于动态数组实现，初始容量为 10，容量不足时会自动扩容。
支持随机访问，get() 和 set() 操作时间复杂度为 O(1)。
线程不安全，需要在多线程环境中手动同步。

🔧 2.2 使用案例

import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        // 创建一个 ArrayList
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        // 遍历
        names.forEach(System.out::println);

        // 获取元素
        System.out.println("First Element: " + names.get(0));

        // 修改元素
        names.set(1, "David");

        // 删除元素
        names.remove("Charlie");

        // 遍历
        names.forEach(System.out::println);
    }
}

🛠 2.3 优化方案

指定初始容量，减少扩容开销：

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

避免频繁删除或插入操作，如果有大量插入/删除操作，建议使用 LinkedList。

⚠️ 2.4 多线程优化

ArrayList 是线程不安全的，可以通过以下方式实现线程安全：

✅ 方案 1：使用 `Collections.synchronizedList()`

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

public class SynchronizedArrayListExample {
    public static void main(String[] args) {
        List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());

        synchronizedList.add("Alice");
        synchronizedList.add("Bob");

        synchronized (synchronizedList) {
            synchronizedList.forEach(System.out::println);
        }
    }
}

✅ 方案 2：使用 `CopyOnWriteArrayList`

import java.util.concurrent.CopyOnWriteArrayList;

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

        list.add("Alice");
        list.add("Bob");

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

🧩 3. `LinkedList` 详解

✅ 3.1 特点

基于双向链表实现，每个节点包含 数据和两个指针。
插入和删除操作快，但随机访问性能较差。
支持双端队列（Deque）操作，可用作 队列（Queue） 或 栈（Stack）。

🔧 3.2 使用案例

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        // 创建一个 LinkedList
        LinkedList<String> list = new LinkedList<>();
        list.add("Alice");
        list.add("Bob");
        list.add("Charlie");

        // 添加到头部和尾部
        list.addFirst("First");
        list.addLast("Last");

        // 获取头部和尾部元素
        System.out.println("First Element: " + list.getFirst());
        System.out.println("Last Element: " + list.getLast());

        // 删除头部和尾部元素
        list.removeFirst();
        list.removeLast();

        // 遍历
        list.forEach(System.out::println);
    }
}

🛠 3.3 优化方案

避免随机访问，因为 get() 操作的时间复杂度为 O(n)。
优先使用 ArrayList，除非有大量的插入/删除操作。

⚠️ 3.4 多线程优化

LinkedList 是线程不安全的，在多线程环境中需要手动同步。

✅ 方案：使用 `Collections.synchronizedList()`

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

public class SynchronizedLinkedListExample {
    public static void main(String[] args) {
        List<String> synchronizedList = Collections.synchronizedList(new LinkedList<>());

        synchronizedList.add("Alice");
        synchronizedList.add("Bob");

        synchronized (synchronizedList) {
            synchronizedList.forEach(System.out::println);
        }
    }
}

🧩 4. `Vector` 详解

✅ 4.1 特点

线程安全的动态数组，所有方法都使用了 synchronized 关键字。
性能较低，因为同步开销大。
不推荐使用，在多线程环境下建议使用 CopyOnWriteArrayList。

🔧 4.2 使用案例

import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        // 创建一个 Vector
        Vector<String> vector = new Vector<>();
        vector.add("Alice");
        vector.add("Bob");
        vector.add("Charlie");

        // 遍历
        vector.forEach(System.out::println);

        // 获取元素
        System.out.println("First Element: " + vector.get(0));

        // 修改元素
        vector.set(1, "David");

        // 删除元素
        vector.remove("Charlie");

        // 遍历
        vector.forEach(System.out::println);
    }
}

🛠 4.3 优化方案

避免使用 Vector，改用 ArrayList 或 CopyOnWriteArrayList。
如果必须使用线程安全的集合，推荐使用 CopyOnWriteArrayList。

🔄 5. 三者对比总结

特性	ArrayList	LinkedList	Vector
底层实现	动态数组	双向链表	动态数组
线程安全	否	否	是
随机访问性能	高	低	高
插入/删除性能	低	高	低
适用场景	读操作频繁	插入/删除操作频繁	多线程环境（不推荐）