性能比较
-
头部插入 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。
