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

威震华夏关云长

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

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

2. // 创建一个长度为5的整型数组
3. int[] arr = new int[5];
4. // 尝试修改数组长度会导致编译错误
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标准库中提供的一个便捷方法，用于创建一个新数组，并将原数组的元素复制到新数组中。新数组的长度可以大于或等于原数组的长度。

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

复制代码

输出：

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

复制代码

3.2 System.arraycopy方法

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

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

复制代码

输出：

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

复制代码

3.3 手动扩容方法

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

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

复制代码

输出：

2. Original array: [1, 2, 3, 4, 5]
3. 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的源码：

2. public static <T> T[] copyOf(T[] original, int newLength) {
3.     return (T[]) copyOf(original, newLength, original.getClass());
4. }
6. public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
7.     @SuppressWarnings("unchecked")
8.     T[] copy = ((Object)newType == (Object)Object[].class)
9.         ? (T[]) new Object[newLength]
10.         : (T[]) Array.newInstance(newType.getComponentType(), newLength);
11.     System.arraycopy(original, 0, copy, 0,
12.                      Math.min(original.length, newLength));
13.     return copy;
14. }

复制代码

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

4.2 System.arraycopy的实现原理

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

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

以下是System.arraycopy的声明：

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

复制代码

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

5. 性能优化技巧

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

5.1 预估数组大小

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

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

复制代码

5.2 使用合适的扩容策略

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

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

2. public class DynamicArray {
3.     private int[] array;
4.     private int size;
5.    
6.     public DynamicArray(int initialCapacity) {
7.         this.array = new int[initialCapacity];
8.         this.size = 0;
9.     }
10.    
11.     public void add(int element) {
12.         if (size == array.length) {
13.             // 比例扩容：增加1.5倍的空间
14.             int newCapacity = array.length + (array.length >> 1);
15.             array = Arrays.copyOf(array, newCapacity);
16.         }
17.         array[size++] = element;
18.     }
19. }

复制代码

5.3 批量操作

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

2. public void addAll(int[] elements) {
3.     ensureCapacity(size + elements.length);
4.     System.arraycopy(elements, 0, array, size, elements.length);
5.     size += elements.length;
6. }
8. private void ensureCapacity(int minCapacity) {
9.     if (minCapacity > array.length) {
10.         int newCapacity = Math.max(minCapacity, array.length + (array.length >> 1));
11.         array = Arrays.copyOf(array, newCapacity);
12.     }
13. }

复制代码

5.4 选择合适的复制方法

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

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

5.5 避免频繁扩容

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

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

6.1 使用集合类

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

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

复制代码

6.2 实现自定义动态数组

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

2. import java.util.Arrays;
4. public class CustomDynamicArray<E> {
5.     private Object[] array;
6.     private int size;
7.    
8.     public CustomDynamicArray(int initialCapacity) {
9.         if (initialCapacity < 0) {
10.             throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
11.         }
12.         this.array = new Object[initialCapacity];
13.         this.size = 0;
14.     }
15.    
16.     public CustomDynamicArray() {
17.         this(10);
18.     }
19.    
20.     public void add(E element) {
21.         if (size == array.length) {
22.             ensureCapacity(size + 1);
23.         }
24.         array[size++] = element;
25.     }
26.    
27.     public void add(int index, E element) {
28.         if (index < 0 || index > size) {
29.             throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
30.         }
31.         
32.         if (size == array.length) {
33.             ensureCapacity(size + 1);
34.         }
35.         
36.         System.arraycopy(array, index, array, index + 1, size - index);
37.         array[index] = element;
38.         size++;
39.     }
40.    
41.     @SuppressWarnings("unchecked")
42.     public E get(int index) {
43.         if (index < 0 || index >= size) {
44.             throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
45.         }
46.         return (E) array[index];
47.     }
48.    
49.     public E remove(int index) {
50.         if (index < 0 || index >= size) {
51.             throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
52.         }
53.         
54.         @SuppressWarnings("unchecked")
55.         E oldValue = (E) array[index];
56.         
57.         int numMoved = size - index - 1;
58.         if (numMoved > 0) {
59.             System.arraycopy(array, index + 1, array, index, numMoved);
60.         }
61.         
62.         array[--size] = null; // 清除引用，帮助垃圾回收
63.         return oldValue;
64.     }
65.    
66.     public int size() {
67.         return size;
68.     }
69.    
70.     private void ensureCapacity(int minCapacity) {
71.         if (minCapacity > array.length) {
72.             int newCapacity = array.length + (array.length >> 1);
73.             if (newCapacity < minCapacity) {
74.                 newCapacity = minCapacity;
75.             }
76.             array = Arrays.copyOf(array, newCapacity);
77.         }
78.     }
79. }

复制代码

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

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

2. import java.util.Arrays;
4. public class ArrayTypeConversion {
5.     public static void main(String[] args) {
6.         Object[] objects = new Object[5];
7.         objects[0] = "Hello";
8.         objects[1] = "World";
9.         objects[2] = 123;
10.         objects[3] = 456.78;
11.         objects[4] = true;
12.         
13.         // 将Object数组转换为String数组
14.         String[] strings = Arrays.copyOf(objects, objects.length, String[].class);
15.         
16.         // 注意：这会导致ClassCastException，因为不是所有元素都是String类型
17.         try {
18.             System.out.println(Arrays.toString(strings));
19.         } catch (ClassCastException e) {
20.             System.out.println("ClassCastException: " + e.getMessage());
21.         }
22.         
23.         // 正确的做法是只包含String类型的元素
24.         Object[] stringObjects = new Object[2];
25.         stringObjects[0] = "Hello";
26.         stringObjects[1] = "World";
27.         
28.         String[] validStrings = Arrays.copyOf(stringObjects, stringObjects.length, String[].class);
29.         System.out.println(Arrays.toString(validStrings));
30.     }
31. }

复制代码

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

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

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

复制代码

输出：

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

复制代码

6.5 多维数组扩容

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

2. import java.util.Arrays;
4. public class MultiDimensionalArrayExpansion {
5.     public static void main(String[] args) {
6.         int[][] matrix = new int[3][3];
7.         
8.         // 初始化矩阵
9.         for (int i = 0; i < matrix.length; i++) {
10.             for (int j = 0; j < matrix[i].length; j++) {
11.                 matrix[i][j] = i * 3 + j + 1;
12.             }
13.         }
14.         
15.         System.out.println("Original matrix:");
16.         printMatrix(matrix);
17.         
18.         // 扩展矩阵
19.         matrix = expandMatrix(matrix, 5, 5);
20.         
21.         System.out.println("Expanded matrix:");
22.         printMatrix(matrix);
23.     }
24.    
25.     public static int[][] expandMatrix(int[][] original, int newRows, int newCols) {
26.         int[][] expanded = new int[newRows][newCols];
27.         
28.         // 复制原有数据
29.         for (int i = 0; i < Math.min(original.length, newRows); i++) {
30.             System.arraycopy(original[i], 0, expanded[i], 0, Math.min(original[i].length, newCols));
31.         }
32.         
33.         return expanded;
34.     }
35.    
36.     public static void printMatrix(int[][] matrix) {
37.         for (int[] row : matrix) {
38.             System.out.println(Arrays.toString(row));
39.         }
40.     }
41. }

复制代码

输出：

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

复制代码

6.6 性能比较

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

2. import java.util.Arrays;
4. public class ArrayCopyPerformance {
5.     private static final int ARRAY_SIZE = 1000000;
6.     private static final int WARMUP_ITERATIONS = 10;
7.     private static final int MEASUREMENT_ITERATIONS = 100;
8.    
9.     public static void main(String[] args) {
10.         // 准备测试数据
11.         int[] sourceArray = new int[ARRAY_SIZE];
12.         for (int i = 0; i < sourceArray.length; i++) {
13.             sourceArray[i] = i;
14.         }
15.         
16.         // 预热JVM
17.         for (int i = 0; i < WARMUP_ITERATIONS; i++) {
18.             testArraysCopyOf(sourceArray);
19.             testSystemArrayCopy(sourceArray);
20.             testManualCopy(sourceArray);
21.         }
22.         
23.         // 测试Arrays.copyOf性能
24.         long arraysCopyOfTime = measureExecutionTime(() -> testArraysCopyOf(sourceArray), MEASUREMENT_ITERATIONS);
25.         System.out.println("Arrays.copyOf average time: " + arraysCopyOfTime + " ns");
26.         
27.         // 测试System.arraycopy性能
28.         long systemArrayCopyTime = measureExecutionTime(() -> testSystemArrayCopy(sourceArray), MEASUREMENT_ITERATIONS);
29.         System.out.println("System.arraycopy average time: " + systemArrayCopyTime + " ns");
30.         
31.         // 测试手动复制性能
32.         long manualCopyTime = measureExecutionTime(() -> testManualCopy(sourceArray), MEASUREMENT_ITERATIONS);
33.         System.out.println("Manual copy average time: " + manualCopyTime + " ns");
34.     }
35.    
36.     private static void testArraysCopyOf(int[] sourceArray) {
37.         int[] newArray = Arrays.copyOf(sourceArray, sourceArray.length);
38.     }
39.    
40.     private static void testSystemArrayCopy(int[] sourceArray) {
41.         int[] newArray = new int[sourceArray.length];
42.         System.arraycopy(sourceArray, 0, newArray, 0, sourceArray.length);
43.     }
44.    
45.     private static void testManualCopy(int[] sourceArray) {
46.         int[] newArray = new int[sourceArray.length];
47.         for (int i = 0; i < sourceArray.length; i++) {
48.             newArray[i] = sourceArray[i];
49.         }
50.     }
51.    
52.     private static long measureExecutionTime(Runnable task, int iterations) {
53.         long totalTime = 0;
54.         
55.         for (int i = 0; i < iterations; i++) {
56.             long startTime = System.nanoTime();
57.             task.run();
58.             long endTime = System.nanoTime();
59.             totalTime += (endTime - startTime);
60.         }
61.         
62.         return totalTime / iterations;
63.     }
64. }

复制代码

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

7. 总结

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

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

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

版权声明

1、转载或引用本网站内容(Java数组扩容全攻略 从固定长度限制到动态扩展技巧 深入解析Arrays.copyOf与System.arraycopy实现原理及性能优化)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://pixtech.org/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://pixtech.org/thread-40153-1-1.html