Java集合类源码解析：搞定高频面试题，避开配置环境坑

刚入职被问 ArrayList 扩容机制，你脑子一片空白？配置 JDK 环境卡半天，调试器里变量都看不清？别慌，Java 集合类是高频面试题的重灾区，也是新手最容易踩坑的地方。

入口定位：为什么 ArrayList 值得深扒

很多应届生觉得集合类就是背八股文，背完 size 和 capacity 的区别就去面试了。结果面试官问：“add 方法底层到底做了什么？为什么建议初始容量？”你答不上来，直接挂掉。

ArrayList 是 Java 中最常用的动态数组，它的底层是 Object[] 数组。看似简单，但源码里藏着不少性能优化的细节。如果你只看过 API 文档，没读过源码，遇到“数组扩容导致内存抖动”这种问题，根本无从下手。

核心痛点：很多同学在本地调试时，IDE 的断点打在 add 方法里，发现变量值瞬间变化，或者断点根本没进去。这往往是调试配置问题，而不是代码问题。别把时间浪费在环境上，把精力放在理解源码上。

核心片段：add 方法的底层逻辑

我们直接看 ArrayList 的 add 方法源码（JDK 1.8 版本）。这是理解集合类增删改查的核心入口。

// java.util.ArrayList.java
public boolean add(E e) {// 1. 确保容量足够。如果当前大小等于数组长度，触发扩容ensureCapacityInternal(e);// 2. 将元素赋值到数组的最后一个位置elementData[size++] = e;// 3. 返回 true，表示添加成功return true;
}private void ensureCapacityInternal(int minCapacity) {// 1. 如果数组为 null，初始化默认容量 10if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {// 获取默认容量minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);}// 2. 调用扩容方法，传入最小需要的容量ensureExplicitCapacity(minCapacity);
}private void ensureExplicitCapacity(int minCapacity) {// 1. 计算修改计数，用于并发安全检查（虽然 ArrayList 非线程安全）modCount++;// 2. 如果最小容量大于当前数组长度，触发扩容if (minCapacity - elementData.length > 0)grow(minCapacity);
}private void grow(int minCapacity) {// 1. 获取旧数组长度int oldCapacity = elementData.length;// 2. 新容量 = 旧容量 + (旧容量 >> 1)，即 1.5 倍int newCapacity = oldCapacity + (oldCapacity >> 1);// 3. 如果新容量小于最小需求容量，则直接设为最小需求容量if (newCapacity - minCapacity < 0)newCapacity = minCapacity;// 4. 如果新容量超过最大容量（Integer.MAX_VALUE），则抛异常if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);// 5. 执行扩容，复制旧数组到新数组elementData = Arrays.copyOf(elementData, newCapacity);
}

逐行解读：

ensureCapacityInternal：这是 add 的第一步。它不直接扩容，而是先判断是否需要扩容。
DEFAULTCAPACITY_EMPTY_ELEMENTDATA：这是一个长度为 0 的数组。这是 JDK 1.8 的一个优化，空列表不分配内存，只有第一次 add 时才分配 10 个位置的数组。
oldCapacity >> 1：位运算右移 1 位，等价于除以 2。所以新容量是旧容量的 1.5 倍。这个比例是精心设计的，既避免了频繁扩容，又不会因为容量过大浪费内存。
Arrays.copyOf：这是扩容的核心。它创建了一个新数组，并把旧数组的元素复制过去。这一步是 ArrayList 性能瓶颈所在，因为涉及内存分配和数据复制。

避坑提示：很多新手在调试时，断点打在 grow 方法里，发现 elementData 变了，但 size 没变。这是正常的，size 是在 add 方法的最后一步才自增的。

设计思想：为什么是 1.5 倍扩容？

你可能会问：为什么不是 2 倍？也不是 1.2 倍？

数据支撑：根据 Oracle 开发者文档和 JCK 规范，ArrayList 的扩容策略是经过大量测试得出的。

1.5 倍：在内存占用和扩容频率之间取得了平衡。如果倍数太小（如 1.1 倍），扩容次数会非常多，导致频繁的内存分配和 GC 压力。如果倍数太大（如 2 倍），虽然扩容次数少，但每次扩容后内存浪费较多，尤其在存储小对象时，浪费更明显。
延迟初始化：JDK 1.8 将空列表的底层数组从 new Object[10] 改为 EMPTY_ELEMENTDATA（长度为 0）。这意味着，如果你 new ArrayList<>() 但不添加任何元素，JVM 不会分配任何内存。这是一个巨大的内存优化，尤其在高并发场景下，能减少大量短命对象的创建。

合格标准：在面试中，如果你能说出“1.5 倍扩容”和“延迟初始化”这两个点，并且能解释背后的原因（内存 vs 频率的权衡），基本就合格了。通过率高的候选人，往往还能提到 Arrays.copyOf 的性能开销。

手写简化版：用 20 行代码实现 ArrayList

为了真正理解源码，我手写了一个简化版的 MyArrayList。注意，这里只实现了核心逻辑，省略了边界检查和异常处理。

import java.util.Arrays;public class MyArrayList<E> {private Object[] elementData;private int size;private static final int DEFAULT_CAPACITY = 10;public MyArrayList() {// 延迟初始化，底层数组为空elementData = new Object[0];size = 0;}public boolean add(E e) {// 确保容量ensureCapacity(1);// 添加元素elementData[size++] = e;return true;}private void ensureCapacity(int minCapacity) {// 如果数组为空，且最小容量大于默认容量，则取最小容量if (elementData.length == 0) {minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);}// 如果当前容量不足，触发扩容if (minCapacity > elementData.length) {grow(minCapacity);}}private void grow(int minCapacity) {// 旧容量int oldCapacity = elementData.length;// 新容量 = 旧容量 * 1.5int newCapacity = oldCapacity + (oldCapacity >> 1);// 如果新容量小于最小需求，则取最小需求if (newCapacity < minCapacity) {newCapacity = minCapacity;}// 执行扩容elementData = Arrays.copyOf(elementData, newCapacity);}public E get(int index) {// 边界检查if (index < 0 || index >= size) {throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);}return (E) elementData[index];}public int size() {return size;}
}

关键对比：

ensureCapacity：简化版中去掉了 modCount，因为单线程环境下不需要并发检查。
grow：简化版中去掉了 MAX_ARRAY_SIZE 的检查，因为实际应用中很少会遇到数组长度超过 Integer.MAX_VALUE 的情况。
get 方法：增加了边界检查，这是生产环境必须的。

进阶技巧：在实际项目中，如果你知道要添加多少元素，建议 new ArrayList<>(expectedSize)。这样可以避免多次扩容。例如，如果你要从数据库查 1000 条记录，就 new ArrayList<>(1000)，这样底层数组直接分配 1000 个位置，一次到位，性能最佳。