Java数组扩容原理 · 数组扩容JAVA 深度拆解

从 内存分配 到 数据迁移，从 ArrayList 到原生数组，彻底讲透 Java数组扩容原理。不只是理论，更有实战示例与网友最关心的周边热点。

⚙️ 核心扩容原理 · 暗度陈仓的内存艺术

⚡ 重新分配 · 拷贝溢出

数组扩容本质是“重新分配+数据拷贝”。JVM 寻找更大的连续内存，将旧数据逐一迁移。扩容不是简单的“加大”，而是新瓶装旧酒。旧数组变成“死”数组，新数组成为工作区。

同步扩容：线程内完成，保证数据一致
溢出机制：旧数据末尾被“推”到新位置
GC 隔离：新旧数组内存独立，避免回收混乱

? 数据搬运 · 三步走

以 int[] arr = {1,2,3,4,5} 扩容到100为例：① 拷贝全部旧数据到临时数组 temp；② 将剩余未拷贝部分（溢出）填入后续位置；③ 替换引用，旧数组废弃。每一步都涉及内存连续性保障。

第一步：完整拷贝副本
第二步：溢出填充，利用连续内存
第三步：引用替换，旧数组不可用

?️ 线程安全 · 绝对保险

扩容操作必须在绝对保险的线程内完成。任何并发读写都会导致数据错乱或异常。JDK 中 ArrayList 的扩容由 grow() 方法封装，外部调用无需关心内存细节，但内部同步块保证安全。

扩容时不可触发其他同步操作，避免死锁或状态不一致。

? 热点聚焦 · 网民最关心的扩容话题

? 扩容性能 · 为什么说扩容是“脏活累活”？

数组扩容涉及 O(n) 的数据拷贝，当元素数量巨大时，频繁扩容会严重拖慢响应。网友常问：“ArrayList 每次扩容多少？” 默认是 1.5 倍（旧容量 + 旧容量右移1位）。扩容次数越少，性能越好。建议预分配容量：new ArrayList<>(1000) 避免多次扩容。

扩容因子：1.5 倍是时间与空间的权衡
内存碎片：频繁扩容导致GC压力
优化技巧：使用 ensureCapacity() 或 Arrays.copyOf 手动控制

// ArrayList 扩容核心 (JDK 17)
private void grow(int minCapacity) {
  int oldCapacity = elementData.length;
  int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5倍
  elementData = Arrays.copyOf(elementData, newCapacity);
}

? ArrayList 扩容 vs 原生数组扩容

ArrayList 封装了动态扩容，底层仍是 Object[]，扩容时调用 Arrays.copyOf()。而原生数组一旦创建长度固定，无法真正“扩容”，只能通过新数组+拷贝模拟。网友误区：“数组可以自动扩容吗？” 答案是否定的，所有“扩容”都是新数组的创建与引用替换。

ArrayList：自动扩容，默认10，1.5倍增长
原生数组：手动扩容，int[] newArr = Arrays.copyOf(old, newLength);
LinkedList：无需扩容，但内存开销更大

网友关心：“扩容时原来的数据会丢失吗？” 不会，copyOf 保证完整迁移。

? 拷贝优化 · System.arraycopy 与 Arrays.copyOf

System.arraycopy 是 native 方法，内存拷贝极快；Arrays.copyOf 内部调用前者。网友常混淆：两者都是浅拷贝，但对于基本类型数组完全安全。扩容时推荐使用 Arrays.copyOf，简洁且不易错。

// 高效扩容示例
int[] original = {1,2,3,4,5};
int[] expanded = Arrays.copyOf(original, 10);
// expanded = [1,2,3,4,5,0,0,0,0,0]

System.arraycopy：可指定源位置，目标位置，长度
Arrays.copyOf：更高级，自动填充默认值
注意：多维数组深拷贝需手动遍历

⏳ 数组扩容时间轴 · 从旧数组到新容器

触发扩容：当数组元素已满（如ArrayList add 操作），计算新容量（1.5倍或指定值）。

分配新内存：JVM 在堆中寻找连续内存块，大小为 newCapacity。

数据拷贝：使用 System.arraycopy 将旧数组所有元素拷贝到新数组。

溢出处理：若旧数组末尾有剩余元素（实际不存在），逻辑上“溢出”到新数组后续位置，但实际拷贝已完成全部元素。

引用替换：新数组赋值给原引用，旧数组失去引用，等待GC回收。

? 丰富示例 · 手写扩容与常见陷阱

? 手动模拟数组扩容

// 模拟 ArrayList 扩容逻辑
public static int[] resize(int[] oldArr, int newCapacity) {
  int[] newArr = new int[newCapacity];
  System.arraycopy(oldArr, 0, newArr, 0, Math.min(oldArr.length, newCapacity));
  return newArr;
}
// 使用：int[] bigger = resize(arr, 100);

注意：如果 newCapacity < oldArr.length，会截断数据，这是“缩容”。

⚠️ 常见陷阱 · 线程不安全

多线程环境下同时扩容会导致 数据丢失 或 数组越界。网友常踩坑：使用 ArrayList 未加同步，多个线程 add 触发并发扩容，出现 ArrayIndexOutOfBoundsException。解决方案：使用 CopyOnWriteArrayList 或加锁。

错误示范：多个线程直接调用 list.add()
正确做法：使用 Collections.synchronizedList

? 扩容对比：ArrayList vs Vector

Vector 扩容翻倍（100%增长），ArrayList 增长50%。网友关心：“哪个更省内存？” ArrayList 更节省，但 Vector 线程安全（已过时）。实际开发中，ArrayList 配合显式 ensureCapacity 更优。

? 扩容原理深层剖析 · 为什么不能共享内存？

很多初学者疑惑：“扩容时为什么不直接让新旧数组共用内存？” 这源于 Java 的 GC 机制。如果两个数组引用同一块内存，一旦其中一个引用被回收，另一个将指向无效数据。此外，数据隔离 保证了扩容过程中并发操作的安全性。JVM 设计者选择“拷贝+替换”而非“共享”，是为了确定性行为，避免幽灵读。

另一个关键点：数组扩容是同步的，因为 JVM 需要保证在扩容瞬间，所有线程看到的是完整的新数组或旧数组，绝不会出现“中间状态”。这也是 volatile 关键字无法解决的，必须通过同步块或 final 域保证。

网友常问：“扩容时旧数组真的完全不可用了吗？” 是的，一旦新数组赋值给引用，旧数组就变成垃圾。但若有其他引用指向旧数组，则仍可访问，但数据是旧版本。因此，扩容后应确保所有引用更新。

// 错误示例：持有旧引用
int[] oldRef = arr;
arr = Arrays.copyOf(arr, 100);
// oldRef 仍指向旧数组 (长度5)

理解这些，才算真正掌握 Java数组扩容原理。