Java数组拼接详解：多方法实现、性能考量与最佳实践339

作为一名专业的Java开发者，我们经常会遇到需要将多个数组合并（或称拼接、连接、串联）成一个新数组的场景。尽管Java的数组是固定长度的数据结构，无法像某些动态语言那样直接通过`+`操作符进行拼接，但Java平台提供了多种灵活且高效的方式来实现这一目标。本文将深入探讨Java中串联（合并）数组的各种方法，包括原生API、Stream API以及第三方库的解决方案，并从性能、可读性、适用场景等多个维度进行详细比较，帮助你选择最适合的方案。

在开始之前，需要明确一个核心概念：在Java中，数组一旦创建，其大小就是固定的。因此，任何“串数组”的操作，本质上都是创建一个新的、足够大的数组，然后将原数组的元素逐一复制到新数组中。我们不会修改原始数组，而是得到一个包含所有原数组元素的新数组。

方法一：手动循环复制（基础但灵活）

这是最直接、最容易理解的方法。我们创建一个足够大的新数组，然后使用循环将源数组的元素逐个复制到新数组的相应位置。

适用场景：当你需要完全控制复制过程，或者处理的数组数量不多、元素类型较为简单时。
public class ArrayConcatenation {
public static <T> T[] concatenateArraysManual(T[] arr1, T[] arr2) {
if (arr1 == null && arr2 == null) {
return null; // 或者抛出异常，根据业务需求
}
if (arr1 == null) {
return arr2;
}
if (arr2 == null) {
return arr1;
}
// 创建一个新数组，长度为两个源数组的长度之和
// 注意：这里需要通过反射创建泛型数组
T[] result = (T[]) (().getComponentType(), + );
// 复制第一个数组的元素
for (int i = 0; i < ; i++) {
result[i] = arr1[i];
}
// 复制第二个数组的元素
for (int i = 0; i < ; i++) {
result[ + i] = arr2[i];
}
return result;
}
// 针对基本类型数组的示例 (int[])
public static int[] concatenateIntArraysManual(int[] arr1, int[] arr2) {
if (arr1 == null && arr2 == null) {
return null;
}
if (arr1 == null) {
return arr2;
}
if (arr2 == null) {
return arr1;
}
int[] result = new int[ + ];
for (int i = 0; i < ; i++) {
result[i] = arr1[i];
}
for (int i = 0; i < ; i++) {
result[ + i] = arr2[i];
}
return result;
}
public static void main(String[] args) {
String[] sa1 = {"Hello", "World"};
String[] sa2 = {"Java", "Programming"};
String[] concatenatedStrings = concatenateArraysManual(sa1, sa2);
("手动循环（对象数组）：" + (concatenatedStrings));
int[] ia1 = {1, 2, 3};
int[] ia2 = {4, 5, 6};
int[] concatenatedInts = concatenateIntArraysManual(ia1, ia2);
("手动循环（基本类型数组）：" + (concatenatedInts));
}
}

优点：
易于理解和实现。
不依赖任何外部库或高级API。

缺点：
代码相对冗长。
需要手动管理索引，容易出错。
对于基本类型数组和对象数组需要分别处理，或者使用反射。

方法二：使用 `()`（高效且常用）

`()` 是Java提供的一个原生静态方法，用于在数组之间进行高效的复制。它是一个底层操作，通常由JVM进行优化，因此在性能上表现出色。

方法签名： `public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)`
`src`：源数组。
`srcPos`：源数组中的起始位置。
`dest`：目标数组。
`destPos`：目标数组中的起始位置。
`length`：要复制的元素数量。

适用场景：对性能有较高要求，或处理大量数据时。
public class ArrayConcatenationSystemArrayCopy {
public static <T> T[] concatenateArraysSystemArrayCopy(T[] arr1, T[] arr2) {
if (arr1 == null && arr2 == null) {
return null;
}
if (arr1 == null) {
return arr2;
}
if (arr2 == null) {
return arr1;
}
// 创建新数组
T[] result = (T[]) (().getComponentType(), + );
// 复制第一个数组
(arr1, 0, result, 0, );
// 复制第二个数组
(arr2, 0, result, , );
return result;
}
// 针对基本类型数组的示例 (int[])
public static int[] concatenateIntArraysSystemArrayCopy(int[] arr1, int[] arr2) {
if (arr1 == null && arr2 == null) {
return null;
}
if (arr1 == null) {
return arr2;
}
if (arr2 == null) {
return arr1;
}
int[] result = new int[ + ];
(arr1, 0, result, 0, );
(arr2, 0, result, , );
return result;
}
public static void main(String[] args) {
String[] sa1 = {"Hello", "World"};
String[] sa2 = {"Java", "Programming"};
String[] concatenatedStrings = concatenateArraysSystemArrayCopy(sa1, sa2);
("（对象数组）：" + (concatenatedStrings));
int[] ia1 = {1, 2, 3};
int[] ia2 = {4, 5, 6};
int[] concatenatedInts = concatenateIntArraysSystemArrayCopy(ia1, ia2);
("（基本类型数组）：" + (concatenatedInts));
}
}

优点：
性能极佳，是复制数组元素的首选方法。
代码相对简洁。

缺点：
仍然需要手动创建目标数组。
需要手动计算目标数组的起始复制位置。
对于泛型数组的创建，需要使用反射。

方法三：使用 `()` 结合 `()`

`()` 方法可以方便地复制数组的一部分，并返回一个新的数组。我们可以用它来复制第一个数组，然后用 `()` 复制第二个数组。

方法签名： `public static <T> T[] copyOf(T[] original, int newLength)`

适用场景：当你需要先创建一个包含第一个数组内容的新数组，再追加第二个数组内容时，代码更清晰。
import ;
public class ArrayConcatenationCopyOf {
public static <T> T[] concatenateArraysCopyOf(T[] arr1, T[] arr2) {
if (arr1 == null && arr2 == null) {
return null;
}
if (arr1 == null) {
return arr2;
}
if (arr2 == null) {
return arr1;
}
// 复制第一个数组，并创建足够大的新数组
T[] result = (arr1, + );
// 将第二个数组复制到新数组的末尾
(arr2, 0, result, , );
return result;
}
// 针对基本类型数组的示例 (int[])
public static int[] concatenateIntArraysCopyOf(int[] arr1, int[] arr2) {
if (arr1 == null && arr2 == null) {
return null;
}
if (arr1 == null) {
return arr2;
}
if (arr2 == null) {
return arr1;
}
int[] result = (arr1, + );
(arr2, 0, result, , );
return result;
}
public static void main(String[] args) {
String[] sa1 = {"Hello", "World"};
String[] sa2 = {"Java", "Programming"};
String[] concatenatedStrings = concatenateArraysCopyOf(sa1, sa2);
(" & （对象数组）：" + (concatenatedStrings));
int[] ia1 = {1, 2, 3};
int[] ia2 = {4, 5, 6};
int[] concatenatedInts = concatenateIntArraysCopyOf(ia1, ia2);
(" & （基本类型数组）：" + (concatenatedInts));
}
}

优点：
代码更简洁，特别是创建目标数组时。
结合了 `()` 的便利性和 `()` 的高效性。

缺点：
本质上还是两种复制方式的组合。

方法四：使用 ``（灵活且易于扩展）

对于对象数组，我们可以先将它们转换成 `ArrayList`，利用 `ArrayList` 的动态扩容和 `addAll()` 方法，然后再将 `ArrayList` 转换回数组。这种方法对于拼接多个数组非常方便。

适用场景：当你需要拼接三个或更多数组，或者不确定数组数量时，以及处理对象数组时。
import ;
import ;
import ;
public class ArrayConcatenationArrayList {
public static <T> T[] concatenateArraysArrayList(T[] arr1, T[] arr2) {
if (arr1 == null && arr2 == null) {
return null;
}
if (arr1 == null) {
return arr2;
}
if (arr2 == null) {
return arr1;
}
List<T> list = new ArrayList<>( + );
((arr1));
((arr2));
// 将List转换回数组，需要传递一个与目标数组类型匹配的空数组作为参数
// T[] result = ((T[]) new Object[0]); // 这种方式可能会返回Object[]
// 正确的泛型数组创建方式是传入一个构造器引用
T[] result = ( > 0 ? (arr1, 0) : (arr2, 0));
// 更准确和简洁的方式 (Java 8+)
// T[] result = (size -> (T[]) (().getComponentType(), size));
// 或者如果确定至少有一个数组非空
// T[] result = (size -> (T[]) (().getComponentType(), size));
return result;
}
// 注意：ArrayList 方法对于基本类型数组需要进行装箱和拆箱操作，效率较低
// 如果是基本类型，最好手动循环或
public static void main(String[] args) {
String[] sa1 = {"Hello", "World"};
String[] sa2 = {"Java", "Programming"};
String[] sa3 = {"is", "fun!"};
String[] concatenatedStrings = concatenateArraysArrayList(sa1, sa2);
("ArrayList（对象数组，两个）：" + (concatenatedStrings));
// 拼接多个数组的例子
List<String> combinedList = new ArrayList<>();
((sa1));
((sa2));
((sa3));
String[] multiConcatenatedStrings = (new String[0]);
("ArrayList（对象数组，多个）：" + (multiConcatenatedStrings));
}
}

优点：
非常灵活，易于拼接任意数量的数组。
代码可读性高。
无需手动管理索引或数组大小。

缺点：
对于基本类型数组，会涉及到装箱（boxing）和拆箱（unboxing）操作，引入性能开销。
创建了中间的 `List` 对象，增加了内存消耗。
将 `List` 转换回数组时，需要注意泛型数组的创建问题。

方法五：使用 Java 8 Stream API（现代且函数式）

Java 8 引入的 Stream API 提供了强大的数据处理能力，也可以用于数组的拼接。对于对象数组，可以使用 `()`；对于基本类型数组，可以使用对应的基本类型 Stream（如 `IntStream`、`LongStream`、`DoubleStream`）的 `concat()` 方法。

适用场景：当项目使用 Java 8 或更高版本，追求函数式编程风格，或者需要链式操作时。
import ;
import ;
import ;
public class ArrayConcatenationStream {
// 对象数组
public static <T> T[] concatenateArraysStream(T[] arr1, T[] arr2) {
if (arr1 == null &&mpy; arr2 == null) {
return null;
}
if (arr1 == null) {
return arr2;
}
if (arr2 == null) {
return arr1;
}

return ((arr1), (arr2))
.toArray(size -> (T[]) (().getComponentType(), size));
// 对于知道具体类型的情况，可以写成：
// return ((arr1), (arr2)).toArray(String[]::new);
}
// 基本类型数组 (int[])
public static int[] concatenateIntArraysStream(int[] arr1, int[] arr2) {
if (arr1 == null &&mpy; arr2 == null) {
return null;
}
if (arr1 == null) {
return arr2;
}
if (arr2 == null) {
return arr1;
}
return ((arr1), (arr2)).toArray();
}
public static void main(String[] args) {
String[] sa1 = {"Hello", "World"};
String[] sa2 = {"Java", "Programming"};
String[] concatenatedStrings = concatenateArraysStream(sa1, sa2);
("Stream API（对象数组）：" + (concatenatedStrings));
int[] ia1 = {1, 2, 3};
int[] ia2 = {4, 5, 6};
int[] concatenatedInts = concatenateIntArraysStream(ia1, ia2);
("Stream API（基本类型数组）：" + (concatenatedInts));

// 拼接多个对象数组
String[] sa3 = {"is", "powerful"};
String[] multiConcatenatedStrings = (sa1, sa2, sa3)
.flatMap(Arrays::stream)
.toArray(String[]::new);
("Stream API（多个对象数组）：" + (multiConcatenatedStrings));
}
}

优点：
代码非常简洁和富有表现力，尤其是对于拼接多个数组。
函数式编程风格，更符合现代Java开发趋势。
对于对象数组，性能通常不错。

缺点：
对于基本类型数组，如果先 `stream()` 再 `concat()` 再 `toArray()`，可能存在一定的装箱/拆箱开销（尽管 `IntStream` 等原始流避免了这一点，但它们是专门为基本类型设计的）。
相较于 `()`，在处理超大数组时，性能可能会略有下降，因为涉及更多的中间对象和方法调用。
对于不熟悉Stream API的开发者来说，可读性可能略差。

方法六：使用第三方库（如 Apache Commons Lang 的 `ArrayUtils`）

在企业级开发中，我们常常会引入一些成熟的第三方库来简化开发，提高代码质量。Apache Commons Lang 库中的 `ArrayUtils` 类提供了非常方便的数组操作方法，包括数组的拼接。

引入依赖（Maven）：
<dependency>
<groupId></groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version> 
</dependency>

方法签名： `public static <T> T[] addAll(T[] array1, T[] array2)` （以及对应的基本类型版本，如 `int[] addAll(int[] array1, int[] array2)`）

适用场景：项目已经引入了 Commons Lang 库，或者希望代码更简洁、健壮，且对性能要求不是极致苛刻时。
import ;
import ;
public class ArrayConcatenationCommonsLang {
public static void main(String[] args) {
String[] sa1 = {"Hello", "World"};
String[] sa2 = {"Java", "Programming"};
// 对象数组
String[] concatenatedStrings = (sa1, sa2);
("Commons Lang ArrayUtils（对象数组）：" + (concatenatedStrings));
int[] ia1 = {1, 2, 3};
int[] ia2 = {4, 5, 6};
// 基本类型数组
int[] concatenatedInts = (ia1, ia2);
("Commons Lang ArrayUtils（基本类型数组）：" + (concatenatedInts));
// 拼接多个数组
String[] sa3 = {"is", "easy"};
String[] multiConcatenated = (sa1, sa2, sa3);
("Commons Lang ArrayUtils（多个对象数组）：" + (multiConcatenated));
}
}

优点：
API非常简洁，一行代码即可完成拼接。
对 `null` 数组有良好的处理，会将其视为空数组。
同时支持对象数组和所有基本类型数组。
提供重载方法支持拼接多个数组。

缺点：
引入了第三方库的依赖。
内部实现通常是基于 `()`，但因为有额外的封装和 `null` 检查，在极致性能上可能略逊于直接使用 `()`。

性能比较与选择建议

| 方法 | 性能 | 可读性 | 适用场景 | 依赖 | 备注 |

|-----------------------|----------------------------|------------------------|-------------------------------------------------|-------------------|---------------------------------------------------|

| 手动循环 | 一般 | 良好 | 教学，少量元素，无外部依赖 | 无 | 需要手动管理索引，代码冗长 |

| `()` | 最佳 | 中等 | 对性能要求极高，大量数据 | 无 | 最底层高效，但需手动创建目标数组和管理索引 |

| `()` + `()` | 优秀 | 良好 | 兼顾效率和创建目标数组的便利性 | 无 | 常用的组合方式 |

总结与最佳实践建议：

性能敏感场景（大量数据）：首选 `()` 或 `()` 结合 `()`。它们是Java原生且高度优化的解决方案，性能最好。

对象数组拼接多个：
Java 8+ 项目：优先考虑 Stream API 的 `()` 或 `flatMap()` 方式，代码简洁且富有表现力。
Java 8 以下或不想用 Stream： `ArrayList` 方式非常灵活，易于处理多个数组，但注意内存开销和 `List` 到数组的转换。
已引入 Commons Lang： `()` 是最简单、最健壮的选择。

基本类型数组拼接多个：
Stream API 的 `()` 等原始流是可行的现代化方案。
如果追求极致性能且无需第三方库，依然是手动 `()` 的变种实现最为高效。
`()` 也提供了基本类型数组的重载，非常方便。

最简单、通用的两个数组拼接： `()` + `()` 是一个兼顾了效率和代码可读性的好选择。

避免：除非是学习目的，一般不推荐手动循环遍历来拼接数组，因为它冗长且容易出错。`ArrayList` 方式不适合对基本类型数组进行性能敏感的拼接。

选择哪种方法，最终取决于你的具体需求：是追求极致的性能，还是更看重代码的简洁性、可读性，亦或是项目已有的依赖和Java版本。理解每种方法的优缺点，能够帮助你做出明智的选择。

2025-11-20

上一篇：Java乱码终结者：字符读取、编码与解决方案全攻略

下一篇：Java字符滚动效果实现详解：从控制台到GUI动画的全方位指南