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

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

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

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

📖 1. 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 优化方案

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

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

2. 避免频繁删除或插入操作，如果有大量插入/删除操作，建议使用 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 优化方案

1. 避免随机访问，因为 get() 操作的时间复杂度为 O(n)。
2. 优先使用 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 优化方案

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

🔄 5. 三者对比总结

⚙️ 6. 总结与推荐

1. ArrayList 是最常用的集合类，适用于 读操作频繁 的场景。
2. LinkedList 适用于 插入/删除操作频繁 的场景。
3. Vector 是线程安全的集合，但 不推荐使用，可用 CopyOnWriteArrayList 替代。

在实际开发中，推荐选择 ArrayList 和 CopyOnWriteArrayList。