Java数组扩容全攻略从固定长度限制到动态扩展技巧深入解析Arrays.copyOf与System.arraycopy实现原理及性能优化

威震华夏关云长 · 发表于 2025-9-30 20:10:01

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

1. Java数组的基本概念与固定长度限制

Java数组是一种基本的数据结构，用于存储固定大小的相同类型元素的集合。数组在Java中是对象，它们存储在堆内存中。数组的一个重要特性是它们的长度是固定的，一旦创建就不能更改。这意味着如果需要存储更多元素，就必须创建一个新的更大的数组，并将旧数组中的元素复制到新数组中。

// 创建一个长度为5的整型数组
int[] arr = new int[5];
// 尝试修改数组长度会导致编译错误
// arr.length = 10; // 编译错误：无法为最终变量length赋值

复制代码

这种固定长度的限制在某些情况下可能会带来不便，特别是当我们不知道需要存储多少元素时。这就是为什么Java提供了集合框架（如ArrayList），它们内部使用数组并自动处理扩容操作。

2. 数组扩容的必要性和常见场景

数组扩容在许多编程场景中都是必要的，特别是当我们处理动态数据集时。以下是一些常见的需要数组扩容的场景：

1. 动态数据集合：当我们需要存储的数据量在运行时才能确定，或者数据量会随时间增长时。
2. 缓冲区扩展：在实现缓冲区或队列等数据结构时，可能需要根据需要扩展存储空间。
3. 数据导入/导出：从文件或数据库读取数据时，可能需要动态调整数组大小以适应数据量。
4. 算法实现：某些算法（如动态规划）可能需要根据中间结果调整数据结构的大小。

在这些场景中，直接使用固定长度的数组可能会导致以下问题：

• 预先分配的数组太小，无法容纳所有数据，导致数组越界异常。
• 预先分配的数组太大，浪费内存空间。

因此，了解如何有效地扩容数组对于Java开发者来说是非常重要的。

3. Java中数组扩容的主要方法

Java提供了几种方法来实现数组扩容，其中最常用的是Arrays.copyOf和System.arraycopy。此外，还可以手动创建新数组并复制元素。

3.1 Arrays.copyOf方法

Arrays.copyOf方法是Java标准库中提供的一个便捷方法，用于创建一个新数组，并将原数组的元素复制到新数组中。新数组的长度可以大于或等于原数组的长度。

import java.util.Arrays;
public class ArrayCopyExample {
public static void main(String[] args) {
int[] originalArray = {1, 2, 3, 4, 5};
// 使用Arrays.copyOf扩容数组
int[] expandedArray = Arrays.copyOf(originalArray, 10);
System.out.println("Original array: " + Arrays.toString(originalArray));
System.out.println("Expanded array: " + Arrays.toString(expandedArray));
}
}

复制代码

输出：

Original array: [1, 2, 3, 4, 5]
Expanded array: [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

复制代码

3.2 System.arraycopy方法

System.arraycopy是一个本地方法，用于将源数组中的元素复制到目标数组。它提供了更细粒度的控制，允许指定源数组和目标数组的起始位置以及复制的元素数量。

import java.util.Arrays;
public class SystemArrayCopyExample {
public static void main(String[] args) {
int[] sourceArray = {1, 2, 3, 4, 5};
int[] destinationArray = new int[10];
// 使用System.arraycopy复制数组
System.arraycopy(sourceArray, 0, destinationArray, 0, sourceArray.length);
System.out.println("Source array: " + Arrays.toString(sourceArray));
System.out.println("Destination array: " + Arrays.toString(destinationArray));
}
}

复制代码

输出：

Source array: [1, 2, 3, 4, 5]
Destination array: [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

复制代码

3.3 手动扩容方法

除了使用上述方法外，还可以手动创建新数组并复制元素：

import java.util.Arrays;
public class ManualArrayExpansion {
public static void main(String[] args) {
int[] originalArray = {1, 2, 3, 4, 5};
// 手动创建新数组并复制元素
int[] expandedArray = new int[10];
for (int i = 0; i < originalArray.length; i++) {
expandedArray[i] = originalArray[i];
}
System.out.println("Original array: " + Arrays.toString(originalArray));
System.out.println("Expanded array: " + Arrays.toString(expandedArray));
}
}

复制代码

输出：

Original array: [1, 2, 3, 4, 5]
Expanded array: [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

复制代码

4. Arrays.copyOf与System.arraycopy的实现原理

4.1 Arrays.copyOf的实现原理

Arrays.copyOf方法实际上是System.arraycopy的一个封装，提供了更简洁的API。让我们看一下Arrays.copyOf的源码：

public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}

复制代码

从源码可以看出，Arrays.copyOf方法首先创建一个新的数组，然后调用System.arraycopy将原数组的内容复制到新数组中。这个方法的主要优点是它简化了数组扩容的过程，开发者不需要手动创建新数组。

4.2 System.arraycopy的实现原理

System.arraycopy是一个本地方法，它的实现依赖于JVM的具体实现。在HotSpot JVM中，System.arraycopy的实现使用了多种优化技术，包括：

1. 类型检查：确保源数组和目标数组的类型兼容。
2. 边界检查：确保源和目标的位置以及长度不会导致数组越界。
3. 内存复制：使用高效的内存复制操作，如memcpy或类似的方法。

以下是System.arraycopy的声明：

public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);

复制代码

由于System.arraycopy是一个本地方法，它可以直接访问内存，这使得它比Java循环复制更快。此外，JVM可能会对System.arraycopy进行特殊优化，例如使用SIMD指令或并行处理来加速复制过程。

5. 性能优化技巧

在处理数组扩容时，性能是一个重要的考虑因素。以下是一些优化技巧：

5.1 预估数组大小

如果可能，尽量预估数组所需的大小，并在创建数组时分配足够的空间。这样可以减少扩容操作的次数。

// 如果知道大约需要1000个元素
int[] array = new int[1000];

复制代码

5.2 使用合适的扩容策略

在动态扩容时，选择合适的扩容策略可以显著提高性能。常见的策略包括：

• 固定增量扩容：每次扩容增加固定大小的空间。
• 比例扩容：每次扩容按当前大小的一定比例增加空间（如1.5倍或2倍）。

public class DynamicArray {
private int[] array;
private int size;
public DynamicArray(int initialCapacity) {
this.array = new int[initialCapacity];
this.size = 0;
}
public void add(int element) {
if (size == array.length) {
// 比例扩容：增加1.5倍的空间
int newCapacity = array.length + (array.length >> 1);
array = Arrays.copyOf(array, newCapacity);
}
array[size++] = element;
}
}

复制代码

5.3 批量操作

如果需要添加多个元素，考虑实现批量添加方法，这样可以减少扩容次数。

public void addAll(int[] elements) {
ensureCapacity(size + elements.length);
System.arraycopy(elements, 0, array, size, elements.length);
size += elements.length;
}
private void ensureCapacity(int minCapacity) {
if (minCapacity > array.length) {
int newCapacity = Math.max(minCapacity, array.length + (array.length >> 1));
array = Arrays.copyOf(array, newCapacity);
}
}

复制代码

5.4 选择合适的复制方法

在不同的场景下，选择合适的数组复制方法可以提高性能：

• Arrays.copyOf：适用于简单的数组扩容，代码简洁。
• System.arraycopy：适用于需要更细粒度控制的场景，性能通常更好。
• 手动循环复制：适用于需要进行特殊处理的场景，但性能通常较差。

5.5 避免频繁扩容

频繁的数组扩容会导致性能下降，因为每次扩容都需要创建新数组并复制元素。尽量减少扩容次数，例如通过预估数组大小或使用合适的扩容策略。

6. 动态扩展技巧和最佳实践

6.1 使用集合类

在大多数情况下，使用Java集合类（如ArrayList）比直接使用数组更方便，因为它们已经实现了动态扩容机制。

import java.util.ArrayList;
public class ArrayListExample {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
// 添加元素，ArrayList会自动处理扩容
for (int i = 0; i < 100; i++) {
list.add(i);
}
System.out.println("List size: " + list.size());
}
}

复制代码

6.2 实现自定义动态数组

如果需要更精细的控制，可以实现自己的动态数组类：

import java.util.Arrays;
public class CustomDynamicArray<E> {
private Object[] array;
private int size;
public CustomDynamicArray(int initialCapacity) {
if (initialCapacity < 0) {
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
}
this.array = new Object[initialCapacity];
this.size = 0;
}
public CustomDynamicArray() {
this(10);
}
public void add(E element) {
if (size == array.length) {
ensureCapacity(size + 1);
}
array[size++] = element;
}
public void add(int index, E element) {
if (index < 0 || index > size) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
if (size == array.length) {
ensureCapacity(size + 1);
}
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = element;
size++;
}
@SuppressWarnings("unchecked")
public E get(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
return (E) array[index];
}
public E remove(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
@SuppressWarnings("unchecked")
E oldValue = (E) array[index];
int numMoved = size - index - 1;
if (numMoved > 0) {
System.arraycopy(array, index + 1, array, index, numMoved);
}
array[--size] = null; // 清除引用，帮助垃圾回收
return oldValue;
}
public int size() {
return size;
}
private void ensureCapacity(int minCapacity) {
if (minCapacity > array.length) {
int newCapacity = array.length + (array.length >> 1);
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
array = Arrays.copyOf(array, newCapacity);
}
}
}

复制代码

6.3 使用Arrays.copyOf进行类型转换

Arrays.copyOf可以用于数组类型转换：

import java.util.Arrays;
public class ArrayTypeConversion {
public static void main(String[] args) {
Object[] objects = new Object[5];
objects[0] = "Hello";
objects[1] = "World";
objects[2] = 123;
objects[3] = 456.78;
objects[4] = true;
// 将Object数组转换为String数组
String[] strings = Arrays.copyOf(objects, objects.length, String[].class);
// 注意：这会导致ClassCastException，因为不是所有元素都是String类型
try {
System.out.println(Arrays.toString(strings));
} catch (ClassCastException e) {
System.out.println("ClassCastException: " + e.getMessage());
}
// 正确的做法是只包含String类型的元素
Object[] stringObjects = new Object[2];
stringObjects[0] = "Hello";
stringObjects[1] = "World";
String[] validStrings = Arrays.copyOf(stringObjects, stringObjects.length, String[].class);
System.out.println(Arrays.toString(validStrings));
}
}

复制代码

6.4 使用System.arraycopy进行部分复制

System.arraycopy可以用于复制数组的一部分：

import java.util.Arrays;
public class PartialArrayCopy {
public static void main(String[] args) {
int[] source = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] destination = new int[10];
// 复制源数组的第3到第7个元素到目标数组的第2个位置开始
System.arraycopy(source, 2, destination, 1, 5);
System.out.println("Source: " + Arrays.toString(source));
System.out.println("Destination: " + Arrays.toString(destination));
}
}

复制代码

输出：

Source: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Destination: [0, 3, 4, 5, 6, 7, 0, 0, 0, 0]

复制代码

6.5 多维数组扩容

多维数组扩容需要更复杂的处理，因为每个维度都需要单独处理：

import java.util.Arrays;
public class MultiDimensionalArrayExpansion {
public static void main(String[] args) {
int[][] matrix = new int[3][3];
// 初始化矩阵
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
matrix[i][j] = i * 3 + j + 1;
}
}
System.out.println("Original matrix:");
printMatrix(matrix);
// 扩展矩阵
matrix = expandMatrix(matrix, 5, 5);
System.out.println("Expanded matrix:");
printMatrix(matrix);
}
public static int[][] expandMatrix(int[][] original, int newRows, int newCols) {
int[][] expanded = new int[newRows][newCols];
// 复制原有数据
for (int i = 0; i < Math.min(original.length, newRows); i++) {
System.arraycopy(original[i], 0, expanded[i], 0, Math.min(original[i].length, newCols));
}
return expanded;
}
public static void printMatrix(int[][] matrix) {
for (int[] row : matrix) {
System.out.println(Arrays.toString(row));
}
}
}

复制代码

输出：

Original matrix:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
Expanded matrix:
[1, 2, 3, 0, 0]
[4, 5, 6, 0, 0]
[7, 8, 9, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]

复制代码

6.6 性能比较

让我们比较一下不同数组复制方法的性能：

import java.util.Arrays;
public class ArrayCopyPerformance {
private static final int ARRAY_SIZE = 1000000;
private static final int WARMUP_ITERATIONS = 10;
private static final int MEASUREMENT_ITERATIONS = 100;
public static void main(String[] args) {
// 准备测试数据
int[] sourceArray = new int[ARRAY_SIZE];
for (int i = 0; i < sourceArray.length; i++) {
sourceArray[i] = i;
}
// 预热JVM
for (int i = 0; i < WARMUP_ITERATIONS; i++) {
testArraysCopyOf(sourceArray);
testSystemArrayCopy(sourceArray);
testManualCopy(sourceArray);
}
// 测试Arrays.copyOf性能
long arraysCopyOfTime = measureExecutionTime(() -> testArraysCopyOf(sourceArray), MEASUREMENT_ITERATIONS);
System.out.println("Arrays.copyOf average time: " + arraysCopyOfTime + " ns");
// 测试System.arraycopy性能
long systemArrayCopyTime = measureExecutionTime(() -> testSystemArrayCopy(sourceArray), MEASUREMENT_ITERATIONS);
System.out.println("System.arraycopy average time: " + systemArrayCopyTime + " ns");
// 测试手动复制性能
long manualCopyTime = measureExecutionTime(() -> testManualCopy(sourceArray), MEASUREMENT_ITERATIONS);
System.out.println("Manual copy average time: " + manualCopyTime + " ns");
}
private static void testArraysCopyOf(int[] sourceArray) {
int[] newArray = Arrays.copyOf(sourceArray, sourceArray.length);
}
private static void testSystemArrayCopy(int[] sourceArray) {
int[] newArray = new int[sourceArray.length];
System.arraycopy(sourceArray, 0, newArray, 0, sourceArray.length);
}
private static void testManualCopy(int[] sourceArray) {
int[] newArray = new int[sourceArray.length];
for (int i = 0; i < sourceArray.length; i++) {
newArray[i] = sourceArray[i];
}
}
private static long measureExecutionTime(Runnable task, int iterations) {
long totalTime = 0;
for (int i = 0; i < iterations; i++) {
long startTime = System.nanoTime();
task.run();
long endTime = System.nanoTime();
totalTime += (endTime - startTime);
}
return totalTime / iterations;
}
}

复制代码

这个性能测试的结果可能会因JVM版本、硬件配置等因素而有所不同，但通常情况下，System.arraycopy的性能最好，其次是Arrays.copyOf，最后是手动循环复制。

7. 总结

Java数组的固定长度特性在某些情况下可能会带来不便，但通过使用Arrays.copyOf和System.arraycopy等方法，我们可以实现高效的数组扩容。Arrays.copyOf提供了简洁的API，而System.arraycopy则提供了更细粒度的控制和更好的性能。

在实际应用中，我们应该根据具体需求选择合适的扩容策略和复制方法。对于大多数情况，使用Java集合类（如ArrayList）是更方便的选择，因为它们已经实现了高效的动态扩容机制。如果需要更精细的控制，可以实现自己的动态数组类。

通过理解数组扩容的原理和优化技巧，我们可以编写出更高效、更健壮的Java代码。

	通知：来制造点氛围！（增加进阶任务）	03-01 22:34
	通知：版主招募中！来加入我们吧！	03-01 19:23
	通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！	10-23 09:31

活动公告

Java数组扩容全攻略从固定长度限制到动态扩展技巧深入解析Arrays.copyOf与System.arraycopy实现原理及性能优化

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

立华奏

站长推荐 /1

友情链接

Telegram

Discord

Tencent QQ

活动公告

Java数组扩容全攻略 从固定长度限制到动态扩展技巧 深入解析Arrays.copyOf与System.arraycopy实现原理及性能优化

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

立华奏

站长推荐 /1

友情链接

Telegram

Discord

Tencent QQ

Java数组扩容全攻略从固定长度限制到动态扩展技巧深入解析Arrays.copyOf与System.arraycopy实现原理及性能优化