砍材农夫

性能比较

头部插入 LinkedList 最快（直接修改头指针）ArrayList 和 Vector 很慢（需要移动大量元素）。
中间插入 ArrayList 和 Vector 仍然需要移动元素，但 LinkedList 需要遍历到中间位置，因此时间也很长。
尾部插入 ArrayList 和 LinkedList 几乎一样快（数组扩容和链表追加），Vector 因为有同步而稍慢。

package com.jysemel.java.basic.collection;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class ListInsertPerformance {

    private static final int INSERT_COUNT = 100_000; // 插入元素数量

    public static void main(String[] args) {
        // 测试头部插入
        testInsert("头部插入", list -> list.add(0, 1));
        // 测试中间插入
        testInsert("中间插入", list -> list.add(list.size() / 2, 1));
        // 测试尾部插入
        testInsert("尾部插入", list -> list.add(1));
    }

    interface InsertOperation {
        void insert(List<Integer> list);
    }

    private static void testInsert(String description, InsertOperation op) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        LinkedList<Integer> linkedList = new LinkedList<>();
        Vector<Integer> vector = new Vector<>();

        System.out.println("=== " + description + " 测试 (" + INSERT_COUNT + "次) ===");

        long start, end;

        // ArrayList
        start = System.nanoTime();
        for (int i = 0; i < INSERT_COUNT; i++) {
            op.insert(arrayList);
        }
        end = System.nanoTime();
        System.out.printf("ArrayList 耗时: %.2f ms%n", (end - start) / 1e6);

        // LinkedList
        start = System.nanoTime();
        for (int i = 0; i < INSERT_COUNT; i++) {
            op.insert(linkedList);
        }
        end = System.nanoTime();
        System.out.printf("LinkedList 耗时: %.2f ms%n", (end - start) / 1e6);

        // Vector
        start = System.nanoTime();
        for (int i = 0; i < INSERT_COUNT; i++) {
            op.insert(vector);
        }
        end = System.nanoTime();
        System.out.printf("Vector 耗时: %.2f ms%n", (end - start) / 1e6);

        System.out.println();
    }
}

访问性能对比

ArrayList 和 Vector 支持高效的随机访问（O(1)），而 LinkedList 则非常慢（O(n)）

package com.jysemel.java.basic.collection;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class ListRandomAccess {

    private static final int SIZE = 100_000;
    private static final int ACCESS_COUNT = 1_000_000;

    public static void main(String[] args) {
        // 初始化列表
        ArrayList<Integer> arrayList = new ArrayList<>(SIZE);
        LinkedList<Integer> linkedList = new LinkedList<>();
        Vector<Integer> vector = new Vector<>(SIZE);

        for (int i = 0; i < SIZE; i++) {
            arrayList.add(i);
            linkedList.add(i);
            vector.add(i);
        }

        System.out.println("=== 随机访问性能测试（" + ACCESS_COUNT + "次）===");

        // ArrayList
        long start = System.nanoTime();
        for (int i = 0; i < ACCESS_COUNT; i++) {
            int index = (int) (Math.random() * SIZE);
            arrayList.get(index);
        }
        long end = System.nanoTime();
        System.out.printf("ArrayList 耗时: %.2f ms%n", (end - start) / 1e6);

        // LinkedList
        start = System.nanoTime();
        for (int i = 0; i < ACCESS_COUNT; i++) {
            int index = (int) (Math.random() * SIZE);
            linkedList.get(index);
        }
        end = System.nanoTime();
        System.out.printf("LinkedList 耗时: %.2f ms%n", (end - start) / 1e6);

        // Vector
        start = System.nanoTime();
        for (int i = 0; i < ACCESS_COUNT; i++) {
            int index = (int) (Math.random() * SIZE);
            vector.get(index);
        }
        end = System.nanoTime();
        System.out.printf("Vector 耗时: %.2f ms%n", (end - start) / 1e6);
    }
}

线程安全性对比

Vector 方法使用 synchronized 修饰，保证了线程安全，但带来性能开销。
ArrayList 非线程安全多线程环境下需要外部同步（如 Collections.synchronizedList）或使用 CopyOnWriteArrayList

package com.jysemel.java.basic.collection;

import java.util.ArrayList;
import java.util.Vector;

public class ListThreadSafety {

    public static void main(String[] args) throws InterruptedException {
        // 测试 ArrayList (线程不安全)
        ArrayList<Integer> arrayList = new ArrayList<>();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                arrayList.add(i);
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                arrayList.add(i);
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("ArrayList 最终大小: " + arrayList.size());
        // 预期是2000，但实际可能小于2000，甚至抛出 ConcurrentModificationException 或 数组越界异常

        // 测试 Vector (线程安全)
        Vector<Integer> vector = new Vector<>();
        Thread t3 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                vector.add(i);
            }
        });
        Thread t4 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                vector.add(i);
            }
        });

        t3.start();
        t4.start();
        t3.join();
        t4.join();
        System.out.println("Vector 最终大小: " + vector.size());
        // 总是输出2000，不会出现异常
    }
}

扩容机制演示

package com.jysemel.java.basic.collection;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Vector;

/**
 * 演示 ArrayList 和 Vector 的扩容机制
 * 运行前需要添加 JVM 参数（用于反射访问 ArrayList 内部数组）：
 *     --add-opens java.base/java.util=ALL-UNNAMED
 */
public class ListCapacityDemo {

    public static void main(String[] args) throws Exception {
        // ---------- ArrayList 扩容演示 ----------
        System.out.println("=== ArrayList 扩容（初始容量 2，扩容因子 1.5）===");
        ArrayList<Integer> arrayList = new ArrayList<>(2); // 初始容量设为2
        System.out.println("初始容量: " + getCapacity(arrayList));

        for (int i = 1; i <= 10; i++) {
            arrayList.add(i);
            System.out.printf("添加第 %2d 个元素后，元素个数: %2d，底层数组容量: %2d%n",
                    i, arrayList.size(), getCapacity(arrayList));
        }

        // ---------- Vector 扩容演示 ----------
        System.out.println("\n=== Vector 扩容（初始容量 2，扩容增量 3）===");
        Vector<Integer> vector = new Vector<>(2, 3); // 初始容量2，每次扩容增加3
        System.out.println("初始容量: " + vector.capacity());

        for (int i = 1; i <= 10; i++) {
            vector.add(i);
            System.out.printf("添加第 %2d 个元素后，元素个数: %2d，底层数组容量: %2d%n",
                    i, vector.size(), vector.capacity());
        }
    }

    /**
     * 通过反射获取 ArrayList 的底层数组长度（容量）
     */
    private static int getCapacity(ArrayList<?> list) throws Exception {
        Field field = ArrayList.class.getDeclaredField("elementData");
        field.setAccessible(true);
        return ((Object[]) field.get(list)).length;
    }
}

总结

ArrayList：动态数组，随机访问快（O(1)），尾部插入快，线程不安全，扩容1.5倍。
LinkedList：双向链表，头部插入快（O(1)），随机访问慢（O(n)），线程不安全，无需扩容。
Vector：动态数组，线程安全（synchronized），性能差，扩容2倍或指定增量，已淘汰。

选型：默认ArrayList；频繁头插改删用LinkedList；多线程用CopyOnWriteArrayList。