Java 数组插入与动态扩容：实现多数组合并及性能优化实践80

在 Java 编程中，数组（Array）是一种非常基础且高效的数据结构，它允许我们存储固定数量的同类型元素。然而，数组的一个核心特性是其“固定大小”：一旦被创建，其长度就无法改变。这给需要“插入”新元素或“合并”其他数组的需求带来了挑战。本文将深入探讨 Java 中如何在不改变数组固定大小本质的前提下，通过创建新数组并进行数据迁移的方式实现元素的插入、多数组的合并以及“相同数组”概念的实际应用，并详细分析性能考量与最佳实践。

理解 Java 数组的固定性与“插入”的本质

在 Java 中，当我们需要向一个已有的数组中“插入”一个或一组元素时，我们并不是在原有数组的内存空间中凭空开辟一个位置。由于数组的物理连续性，任何插入操作都意味着以下两种情况之一：

创建新数组：这是最常见和推荐的做法。我们将创建一个比原数组更大的新数组，然后将原数组中需要保留的元素、待插入的元素按顺序复制到新数组中。
模拟动态扩容：一些复杂的数据结构（如 `ArrayList` 的底层实现）会采用这种策略。当容量不足时，会创建一个更大的新数组，并将旧数组的所有元素复制过去，然后进行插入操作。这本质上也是创建新数组。

因此，在 Java 语境下讨论数组“插入”，其核心思想是数据迁移与新数组的构建。

场景一：插入单个元素到数组

虽然标题侧重“插入相同数组”（我们稍后会解释其含义并进行更深入的讨论），但插入单个元素是其基础。理解这个过程有助于我们构建更复杂的数组合并逻辑。

假设我们有一个整数数组 `int[] originalArray = {1, 2, 3, 5}`，我们想在索引 3 的位置（即元素 3 和 5 之间）插入元素 4。
```java
import ;
public class ArrayInsertion {
/
* 在指定索引位置插入单个元素。
*
* @param originalArray 原始数组。
* @param elementToInsert 待插入的元素。
* @param insertIndex 插入位置的索引。
* @return 插入元素后的新数组。
* @throws IndexOutOfBoundsException 如果 insertIndex 超出有效范围。
*/
public static int[] insertElement(int[] originalArray, int elementToInsert, int insertIndex) {
if (originalArray == null) {
throw new IllegalArgumentException("Original array cannot be null.");
}
if (insertIndex < 0 || insertIndex > ) {
throw new IndexOutOfBoundsException("Insert index " + insertIndex + " is out of bounds for array length " + );
}
int[] newArray = new int[ + 1];
// 1. 复制 originalArray 中 insertIndex 之前的所有元素
(originalArray, 0, newArray, 0, insertIndex);
// 2. 插入新元素
newArray[insertIndex] = elementToInsert;
// 3. 复制 originalArray 中 insertIndex 及其之后的所有元素到新数组的正确位置
(originalArray, insertIndex, newArray, insertIndex + 1, - insertIndex);
return newArray;
}
public static void main(String[] args) {
int[] original = {1, 2, 3, 5};
("原始数组: " + (original));
// 插入元素 4 到索引 3
int element = 4;
int index = 3;
int[] result = insertElement(original, element, index);
("插入 " + element + " 到索引 " + index + " 后: " + (result)); // 输出: [1, 2, 3, 4, 5]
// 插入到开头
int[] resultStart = insertElement(original, 0, 0);
("插入 0 到索引 0 后: " + (resultStart)); // 输出: [0, 1, 2, 3, 5]
// 插入到结尾
int[] resultEnd = insertElement(original, 6, );
("插入 6 到索引 后: " + (resultEnd)); // 输出: [1, 2, 3, 5, 6]
}
}
```

上述代码使用了 `()` 方法。这是一个 native 方法，由 JVM 底层实现，效率远高于手动循环复制，是 Java 中进行数组复制的首选方式。

场景二：插入一个“相同数组”到另一个数组

标题中的“插入相同数组”可能有多种理解。最常见的、且在实际开发中非常有用的解读是：将一个数组（比如 `sourceArray`）的所有元素，作为整体“插入”到另一个数组（比如 `destinationArray`）的指定位置。这里的“相同数组”并非指两个数组的内容完全一致，而是指它们的类型相同，以便能够被无缝地合并。

这相当于将 `sourceArray` 的内容“拼接”到 `destinationArray` 的某个位置，形成一个更大的新数组。

2.1 简单拼接：将一个数组追加到另一个数组的末尾

这是最简单的“插入”形式，即数组的连接或合并。
```java
import ;
public class ArrayConcatenation {
/
* 将 sourceArray 的所有元素追加到 destinationArray 的末尾。
*
* @param destinationArray 目标数组。
* @param sourceArray 待追加的源数组。
* @return 合并后的新数组。
*/
public static int[] concatenateArrays(int[] destinationArray, int[] sourceArray) {
if (destinationArray == null && sourceArray == null) {
return new int[0]; // 都为空，返回空数组
}
if (destinationArray == null) {
return (sourceArray, ); // 目标为空，返回源数组的副本
}
if (sourceArray == null) {
return (destinationArray, ); // 源为空，返回目标数组的副本
}
int[] newArray = new int[ + ];
// 复制 destinationArray 的元素
(destinationArray, 0, newArray, 0, );
// 复制 sourceArray 的元素到新数组的末尾
(sourceArray, 0, newArray, , );
return newArray;
}
public static void main(String[] args) {
int[] arr1 = {1, 2, 3};
int[] arr2 = {4, 5, 6};
("数组1: " + (arr1));
("数组2: " + (arr2));
int[] merged = concatenateArrays(arr1, arr2);
("合并后数组: " + (merged)); // 输出: [1, 2, 3, 4, 5, 6]
int[] arr3 = {7, 8};
int[] arr4 = {}; // 空数组
int[] mergedWithEmpty = concatenateArrays(arr3, arr4);
("与空数组合并后: " + (mergedWithEmpty)); // 输出: [7, 8]
}
}
```

2.2 在指定索引位置插入一个数组的元素

这是最符合“插入相同数组”语义的复杂操作。我们需要将 `sourceArray` 的所有元素作为一个整体，插入到 `destinationArray` 的指定 `insertIndex` 位置。
```java
import ;
public class ArraySplice {
/
* 将 sourceArray 的所有元素作为一个整体插入到 destinationArray 的指定索引位置。
*
* @param destinationArray 目标数组。
* @param sourceArray 待插入的源数组。
* @param insertIndex 插入位置的索引。
* @return 插入元素后的新数组。
* @throws IndexOutOfBoundsException 如果 insertIndex 超出有效范围。
*/
public static int[] insertArrayIntoArray(int[] destinationArray, int[] sourceArray, int insertIndex) {
if (destinationArray == null) {
// 如果目标数组为null，且源数组不为null，则返回源数组的副本
if (sourceArray != null) {
return (sourceArray, );
}
return new int[0]; // 都为空，返回空数组
}
if (sourceArray == null || == 0) {
// 如果源数组为null或为空，则直接返回目标数组的副本
return (destinationArray, );
}
if (insertIndex < 0 || insertIndex > ) {
throw new IndexOutOfBoundsException("Insert index " + insertIndex + " is out of bounds for destination array length " + );
}
int newLength = + ;
int[] newArray = new int[newLength];
// 1. 复制 destinationArray 中 insertIndex 之前的所有元素
(destinationArray, 0, newArray, 0, insertIndex);
// 2. 复制 sourceArray 的所有元素到新数组的 insertIndex 位置
(sourceArray, 0, newArray, insertIndex, );
// 3. 复制 destinationArray 中 insertIndex 及其之后的所有元素到新数组的正确位置
// 注意：新数组的起始位置是 insertIndex +
(destinationArray, insertIndex, newArray, insertIndex + , - insertIndex);
return newArray;
}
public static void main(String[] args) {
int[] arrA = {1, 2, 3, 7, 8};
int[] arrB = {4, 5, 6};
int insertIdx = 3;
("数组A: " + (arrA));
("数组B (待插入): " + (arrB));
("插入索引: " + insertIdx);
int[] result = insertArrayIntoArray(arrA, arrB, insertIdx);
("插入后数组: " + (result)); // 输出: [1, 2, 3, 4, 5, 6, 7, 8]
// 插入到开头
int[] resultStart = insertArrayIntoArray(arrA, arrB, 0);
("插入到开头: " + (resultStart)); // 输出: [4, 5, 6, 1, 2, 3, 7, 8]
// 插入到结尾
int[] resultEnd = insertArrayIntoArray(arrA, arrB, );
("插入到结尾: " + (resultEnd)); // 输出: [1, 2, 3, 7, 8, 4, 5, 6]
// 插入空数组
int[] emptyArr = {};
int[] resultEmpty = insertArrayIntoArray(arrA, emptyArr, 2);
("插入空数组: " + (resultEmpty)); // 输出: [1, 2, 3, 7, 8]
}
}
```

这段代码清晰地展示了如何将一个数组的元素作为一个整体插入到另一个数组的指定位置。其核心逻辑在于三次 `()` 调用，分别处理原数组的前半部分、待插入数组的全部、以及原数组的后半部分。务必精确计算每个 `()` 的 `srcPos`、`destPos` 和 `length` 参数。

性能考量与最佳实践

1. `()` 的优势

正如前文所述，`()` 是实现数组复制和部分元素移动的基石。它是一个 `native` 方法，意味着其实现由底层操作系统和 JVM 直接处理，通常用 C/C++ 编写，并利用了 CPU 缓存和内存操作的优化，因此效率非常高。避免使用手动循环来复制大量数组元素，除非有非常特殊的逻辑需求。

2. 时间与空间复杂度

无论我们是插入单个元素还是一个数组，其操作的时间复杂度都是 O(N)，其中 N 是涉及复制操作的元素总数。这是因为我们总是需要创建一个新的数组，并将旧数组中的至少一部分元素复制到新数组中。空间复杂度也是 O(N)，因为我们需要创建一个新的数组来存储所有元素。对于内存敏感或高性能要求的场景，频繁进行数组扩容和数据迁移可能会带来性能瓶颈。

3. 错误处理

在上述方法中，我们加入了 `null` 检查和 `IndexOutOfBoundsException` 检查，以确保方法的健壮性。在实际开发中，这些边界条件的处理至关重要。

4. 泛型与通用性

上述示例都是针对 `int[]` 原始类型数组。如果需要处理对象数组（例如 `String[]`, `Object[]` 或自定义对象数组），原理是完全相同的，但需要注意以下几点：

创建新数组：`new Object[newLength]` 或 `(T[]) (().getComponentType(), newLength)` (更通用且避免ClassCastException)。
类型擦除：Java 泛型在运行时会进行类型擦除，所以直接创建 `new T[size]` 是不允许的。需要传入 `Class` 对象或使用 ``。

```java
import ;
import ;
public class GenericArraySplice {
/
* 将 sourceArray 的所有元素作为一个整体插入到 destinationArray 的指定索引位置。
* 支持泛型数组。
*
* @param 数组元素的类型。
* @param destinationArray 目标数组。
* @param sourceArray 待插入的源数组。
* @param insertIndex 插入位置的索引。
* @return 插入元素后的新数组。
* @throws IndexOutOfBoundsException 如果 insertIndex 超出有效范围。
* @throws IllegalArgumentException 如果任一数组为null且操作不兼容。
*/
@SuppressWarnings("unchecked") // 编译器无法确定运行时类型安全，此处需手动确认
public static T[] insertArrayIntoArray(T[] destinationArray, T[] sourceArray, int insertIndex) {
if (destinationArray == null && sourceArray == null) {
// 需要一个实际的类型来创建空数组，这里简化为返回null，实际应用中需根据业务确定
return null; // 或者抛出异常
}
Class componentType;
if (destinationArray != null) {
componentType = ().getComponentType();
} else if (sourceArray != null) {
componentType = ().getComponentType();
} else {
return (T[]) (, 0); // 默认Object空数组
}
if (destinationArray == null) {
if (sourceArray != null) {
return (sourceArray, );
}
return (T[]) (componentType, 0);
}
if (sourceArray == null || == 0) {
return (destinationArray, );
}
if (insertIndex < 0 || insertIndex > ) {
throw new IndexOutOfBoundsException("Insert index " + insertIndex + " is out of bounds for destination array length " + );
}
int newLength = + ;
T[] newArray = (T[]) (componentType, newLength);
(destinationArray, 0, newArray, 0, insertIndex);
(sourceArray, 0, newArray, insertIndex, );
(destinationArray, insertIndex, newArray, insertIndex + , - insertIndex);
return newArray;
}
public static void main(String[] args) {
String[] arrS_A = {"apple", "banana", "grape"};
String[] arrS_B = {"orange", "kiwi"};
int insertIdxS = 2;
("字符串数组A: " + (arrS_A));
("字符串数组B (待插入): " + (arrS_B));
("插入索引: " + insertIdxS);
String[] resultS = insertArrayIntoArray(arrS_A, arrS_B, insertIdxS);
("插入后字符串数组: " + (resultS)); // 输出: [apple, banana, orange, kiwi, grape]
Integer[] arrI_A = {10, 20, 30, 40};
Integer[] arrI_B = {100, 200};
int insertIdxI = 1;
("Integer数组A: " + (arrI_A));
("Integer数组B (待插入): " + (arrI_B));
("插入索引: " + insertIdxI);
Integer[] resultI = insertArrayIntoArray(arrI_A, arrI_B, insertIdxI);
("插入后Integer数组: " + (resultI)); // 输出: [10, 100, 200, 20, 30, 40]
}
}
```

需要注意的是，处理泛型数组时，由于 Java 的类型擦除，我们不能直接 `new T[size]`。通常需要通过 `()` 方法，结合数组的组件类型（`().getComponentType()`）来创建新数组。这通常会伴随 `@SuppressWarnings("unchecked")` 注解。

替代方案：更灵活的数据结构

对于大多数需要动态增删元素的场景，直接操作原始数组并不是最佳实践。Java 集合框架提供了更强大、更灵活的数据结构来处理这些需求。

1. ``

`ArrayList` 是一个基于数组实现的动态列表。它会自动处理底层数组的扩容和元素移动，大大简化了编程。当你需要频繁地插入、删除元素时，`ArrayList` 几乎总是比手动操作原始数组更好的选择。
```java
import ;
import ;
import ;
public class ArrayListInsertion {
public static void main(String[] args) {
List listA = new ArrayList(("apple", "banana", "grape"));
List listB = ("orange", "kiwi"); // 待插入的列表
("原始列表A: " + listA);
// 插入单个元素
(1, "cherry"); // 在索引1处插入"cherry"
("插入单个元素后: " + listA); // 输出: [apple, cherry, banana, grape]
// 插入一个列表（集合）的元素到指定位置
(3, listB); // 在索引3处插入listB的所有元素
("插入列表B后: " + listA); // 输出: [apple, cherry, banana, orange, kiwi, grape]
// 简单追加（插入到末尾）
List listC = new ArrayList(("melon"));
(listC);
("追加列表C后: " + listA); // 输出: [apple, cherry, banana, orange, kiwi, grape, melon]
}
}
```

`ArrayList` 提供了 `add(element)`、`add(index, element)`、`addAll(collection)` 和 `addAll(index, collection)` 等方法，能够优雅地处理各种插入需求。其内部机制依然是创建新数组和 `()`，但这些复杂性被封装起来，对开发者透明。

2. ``

如果你的应用场景需要频繁在列表的两端或中间进行插入和删除操作，并且随机访问（按索引访问）的频率不高，那么 `LinkedList` 可能会比 `ArrayList` 表现更好。`LinkedList` 基于双向链表实现，插入和删除元素的平均时间复杂度为 O(1)（如果已知插入位置的节点），而 `ArrayList` 则为 O(N)。

什么时候坚持使用原始数组？

尽管集合框架提供了极大的便利，但在以下场景中，你仍然可能需要直接操作原始数组：

性能极端敏感：在某些对内存和 CPU 周期有极致要求的场景，避免 `ArrayList` 可能带来的对象封装、自动扩容（导致频繁的内存分配和复制）开销。
固定大小的数据集：如果数组大小是已知且固定的，没有插入或删除需求，那么原始数组是最简单、最高效的选择。
与底层库或硬件交互：一些底层 API 或驱动可能直接要求传递原始数组类型。
原始类型数组：`ArrayList` 只能存储对象，如果要存储 `int`、`long`、`double` 等原始类型，`ArrayList` 会自动进行装箱（Boxing），这会带来额外的对象创建和内存开销。这时，`int[]`、`long[]` 等原始类型数组可能更优。

在 Java 中，对固定大小的数组进行“插入”操作，本质上是通过创建一个新的更大的数组，然后将原数组和待插入数组的元素高效地复制到新数组中来实现。`()` 方法是实现这一操作的性能基石。我们详细探讨了插入单个元素和插入一个完整的数组（即合并数组）的实现方式，并提供了通用的泛型数组插入方案。

然而，对于大多数需要动态管理元素集合的业务场景，强烈推荐使用 Java 集合框架中的 `ArrayList` 或 `LinkedList`。它们提供了更高级别的抽象，极大地简化了动态操作的复杂度，并且通常能提供足够的性能。只有在对性能有极端要求、处理固定大小数据或与底层系统交互时，才应考虑直接操作原始数组。理解数组的固定性与“插入”的本质，是成为一名优秀 Java 程序员的基础。

2025-11-03

---

上一篇：Java文本组件与文本操作方法深度解析：从AWT到Swing的演进

下一篇：Java日常编程：掌握核心技术与最佳实践，构建高效健壮应用