性能比较
访问性能对比
线程安全性对比
扩容机制演示
总结
性能比较
头部插入 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;// ArrayListstart = 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);// LinkedListstart = 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);// Vectorstart = 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 + "次）===");// ArrayListlong 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);// LinkedListstart = 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);// Vectorstart = 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); // 初始容量设为2System.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，每次扩容增加3System.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。