ArrayList 扩容机制与性能调优

// 从 CSV 读取 100 万条记录，逐条加入 ArrayList
List<Order> orders = new ArrayList<>();  // 默认容量 10

for (String line : csvLines) {       // csvLines.size() ≈ 1_000_000
    orders.add(parseOrder(line));     // 第 11 次 add 触发第一次扩容
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    // 默认初始容量
    private static final int DEFAULT_CAPACITY = 10;

    // 底层存储数组——ArrayList 的全部秘密都在这里
    transient Object[] elementData;

    // 当前元素个数（不是数组长度！）
    private int size;
}

// 无参构造：指向空数组哨兵，并非直接分配 10 个槽位
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 带初始容量构造：立即分配指定大小的数组
public ArrayList(int initialCapacity) {
    this.elementData = new Object[initialCapacity];
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;

    // ★ 核心公式：右移 1 位 = 除以 2
    // newCapacity = oldCapacity + oldCapacity / 2 = oldCapacity * 1.5
    int newCapacity = oldCapacity + (oldCapacity >> 1);

    // 如果 1.5 倍还不够，直接用请求的最小容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

    // 防止溢出：接近 Integer.MAX_VALUE 时的安全处理
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);

    // Arrays.copyOf 内部调用 System.arraycopy → 真正的开销在这里
    elementData = Arrays.copyOf(elementData, newCapacity);
}

// native 方法，由 JVM 用 C/C++ 实现
public static native void arraycopy(
    Object src,   int srcPos,    // 源数组 + 起始位置
    Object dest,  int destPos,   // 目标数组 + 起始位置
    int length                     // 要拷贝的元素个数
);

// 方式 1：构造时指定初始容量（推荐）
List<Order> orders = new ArrayList<>(1_000_000);

// 方式 2：对已创建的 ArrayList 调用 ensureCapacity
ArrayList<Order> orders2 = new ArrayList<>();
orders2.ensureCapacity(1_000_000);

// ensureCapacity 源码逻辑：
public void ensureCapacity(int minCapacity) {
    if (minCapacity > elementData.length) {
        // 不是恰好等于 minCapacity，而是走 grow() 的 1.5 倍逻辑
        grow(minCapacity);
    }
}

// ✓ 从数据库查询结果转换
List<UserVO> voList = new ArrayList<>(entityList.size());
for (UserEntity e : entityList) {
    voList.add(toVO(e));
}

// ✓ 配合 Stream 使用时，先 collect 再处理
List<String> names = users.stream()
    .map(User::getName)
    .collect(Collectors.toList());  // 内部已预分配

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
List<String> sub = list.subList(1, 3);  // [b, c] — 这是视图，不是副本

sub.set(0, "B");
System.out.println(list);  // [a, B, c, d] ← 原列表也被修改了！

list.add("e");
sub.get(0);  // ✗ 抛出 ConcurrentModificationException
// 原因：subList 持有原列表的 modCount，原列表结构变化导致不一致

// ✓ 安全做法：需要独立副本就 new 一份
List<String> copy = new ArrayList<>(list.subList(1, 3));

// Arrays.asList() → 返回 Arrays$ArrayList（固定大小，不能 add/remove）
List<String> fixed = Arrays.asList("a", "b");
fixed.add("c");   // ✗ UnsupportedOperationException
fixed.set(0, "A"); // ✓ 可以修改元素（底层就是原数组的包装）

// List.of() (Java 9+) → 真正的不可变列表
List<String> immutable = List.of("a", "b");
immutable.add("c");   // ✗ UnsupportedOperationException
immutable.set(0, "A"); // ✗ UnsupportedOperationException
// List.of() 还不允许 null 元素！

// new ArrayList<>(Arrays.asList(...)) → 可变副本
List<String> mutable = new ArrayList<>(Arrays.asList("a", "b"));
mutable.add("c");   // ✓ 完全自由

ArrayList<String> buffer = new ArrayList<>(10000);
// ... 添加数据，最终只用了 200 个槽位
buffer.trimToSize();  // capacity 从 10000 缩为 200，释放多余内存

// 典型场景：长期存活的大列表，填充后不再修改