ArrayList_LinkedList_Vector区别

性能比较
访问性能对比
线程安全性对比
扩容机制演示
总结
性能比较
头部插入 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 list);
}

private static void testInsert(String description, InsertOperation op) {
ArrayList arrayList = new ArrayList<>();
LinkedList linkedList = new LinkedList<>();
Vector 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 arrayList = new ArrayList<>(SIZE);
LinkedList linkedList = new LinkedList<>();
Vector 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 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 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 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 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。