Java中ArrayList、Vector、LinkedList的核心区别与应用场景详解

// ArrayList核心源码（JDK17）
public class ArrayList<E> extends AbstractList<E> implements RandomAccess {
    transient Object[] elementData; // 存储元素的数组
    private int size;
}

// Vector核心源码（与ArrayList结构类似，但方法同步）
public class Vector<E> extends AbstractList<E> implements RandomAccess, Cloneable, java.io.Serializable {
    protected Object[] elementData;
    protected int elementCount;
}

// LinkedList核心源码
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
    transient Node<E> first; // 头节点
    transient Node<E> last; // 尾节点
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;
    }
}

// 方案1：使用Collections.synchronizedList包装
List<String> syncArrayList = Collections.synchronizedList(new ArrayList<>());

// 方案2：高并发读多写少场景使用CopyOnWriteArrayList
List<String> concurrentList = new CopyOnWriteArrayList<>();	

// 性能测试：随机访问10万次
List<Integer> arrayList = new ArrayList<>(Collections.nCopies(100000, 0));
List<Integer> linkedList = new LinkedList<>(Collections.nCopies(100000, 0));

long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
    arrayList.get(i);
}
System.out.println("ArrayList get time: " + (System.currentTimeMillis() - start) + "ms"); // 约2ms

start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
    linkedList.get(i); // 实际是node(i)方法，需遍历链表
}
System.out.println("LinkedList get time: " + (System.currentTimeMillis() - start) + "ms"); // 约450ms

// 中间插入1万次性能对比
List<Integer> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();
for (int i = 0; i < 10000; i++) {
    arrayList.add(i);
    linkedList.add(i);
}

long start = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
    arrayList.add(5000, 999); // 中间位置插入
}
System.out.println("ArrayList insert time: " + (System.currentTimeMillis() - start) + "ms"); // 约85ms

start = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
    linkedList.add(5000, 999); // 链表节点操作
}
System.out.println("LinkedList insert time: " + (System.currentTimeMillis() - start) + "ms"); // 约2ms

LinkedList<String> deque = new LinkedList<>();
deque.addFirst("head");   // 头部插入（O(1)）
deque.addLast("tail");    // 尾部插入（O(1)）
deque.removeFirst();      // 头部删除（O(1)）
deque.getLast();          // 尾部获取（O(1)）

// 作为栈（后进先出）
deque.push("item");
deque.pop();

// 作为队列（先进先出）
deque.offer("item");
deque.poll();

Enumeration<Integer> enumeration = vector.elements();
while (enumeration.hasMoreElements()) {
    Integer element = enumeration.nextElement();
}

List<String> list = new ArrayList<>(1000); // 预分配1000容量

// 不推荐直接使用Vector
// 推荐方案1：同步包装ArrayList（细粒度控制）
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
// 使用时需手动同步
synchronized (syncList) {
    syncList.forEach(...);
}

// 推荐方案2：高并发场景使用CopyOnWriteArrayList
List<String> concurrentList = new CopyOnWriteArrayList<>();
// 写时复制，适合读多写少