java 数组 拼接 详解

在 Java 中，数组拼接是一个常见的操作。由于数组是固定大小的数据结构，无法直接扩展，因此需要创建一个新的数组，将多个数组的数据复制到新数组中。下面是各种拼接数组的方法及其详细解释。

---

1. 使用 System.arraycopy()

System.arraycopy() 是一种高效的方法，可以将一个数组的内容复制到另一个数组。

实现步骤：

1. 创建一个新数组，大小为需要拼接的所有数组的长度之和。
2. 使用 System.arraycopy() 将源数组的数据复制到目标数组中。

示例：

public class ArrayConcat {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        // 创建新数组
        int[] result = new int[array1.length + array2.length];

        // 复制第一个数组到 result
        System.arraycopy(array1, 0, result, 0, array1.length);

        // 复制第二个数组到 result
        System.arraycopy(array2, 0, result, array1.length, array2.length);

        // 输出结果
        for (int num : result) {
            System.out.print(num + " "); // 输出: 1 2 3 4 5 6
        }
    }
}

优点：

• 高效，底层使用了系统级复制。
• 支持多维数组。

---

2. 使用 Arrays.copyOf()

Arrays.copyOf() 是 java.util.Arrays 提供的方法，可以创建新的数组并复制内容。

实现步骤：

1. 使用 Arrays.copyOf() 创建一个足够大的新数组。
2. 使用 System.arraycopy() 将第二个数组复制到新数组的剩余部分。

示例：

import java.util.Arrays;

public class ArrayConcat {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        // 创建新数组并复制 array1 的内容
        int[] result = Arrays.copyOf(array1, array1.length + array2.length);

        // 复制 array2 的内容到 result
        System.arraycopy(array2, 0, result, array1.length, array2.length);

        // 输出结果
        System.out.println(Arrays.toString(result)); // 输出: [1, 2, 3, 4, 5, 6]
    }
}

优点：

• 语法简洁，特别适合拼接两个数组。

---

3. 使用 Streams 拼接（适用于对象数组）

对于对象数组（如 String[]、Integer[] 等），可以使用 Stream.concat 方法来拼接数组。

实现步骤：

1. 使用 Stream.of() 将数组转换为流。
2. 使用 Stream.concat() 合并流。
3. 使用 toArray() 方法将流转换回数组。

示例：

import java.util.stream.Stream;

public class ArrayConcat {
    public static void main(String[] args) {
        String[] array1 = {"A", "B", "C"};
        String[] array2 = {"D", "E", "F"};

        // 使用 Stream 拼接
        String[] result = Stream.concat(Stream.of(array1), Stream.of(array2))
                                .toArray(String[]::new);

        // 输出结果
        for (String str : result) {
            System.out.print(str + " "); // 输出: A B C D E F
        }
    }
}

注意：

• 对于基本数据类型数组（如 int[]），需要先转换为对象数组（如 Integer[]），拼接完成后再转换回基本类型。

---

4. 手动拼接（循环）

通过手动循环的方式，可以将多个数组的数据复制到新数组中。

实现步骤：

1. 创建一个新数组，大小为所有数组长度之和。
2. 使用循环逐个复制数据。

示例：

public class ArrayConcat {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        // 创建新数组
        int[] result = new int[array1.length + array2.length];

        // 手动复制 array1
        for (int i = 0; i < array1.length; i++) {
            result[i] = array1[i];
        }

        // 手动复制 array2
        for (int i = 0; i < array2.length; i++) {
            result[array1.length + i] = array2[i];
        }

        // 输出结果
        for (int num : result) {
            System.out.print(num + " "); // 输出: 1 2 3 4 5 6
        }
    }
}

优点：

• 灵活，可以轻松定制拼接逻辑。
• 不依赖额外的工具类。

缺点：

• 代码较为冗长，不如其他方法简洁。

---

5. 使用 ArrayUtils.addAll()（Apache Commons Lang 库）

ArrayUtils.addAll() 是 Apache Commons Lang 提供的一个工具方法，可以直接拼接数组。

实现步骤：

1. 引入 Apache Commons Lang 的依赖。
2. 使用 ArrayUtils.addAll() 方法拼接多个数组。

示例：

import org.apache.commons.lang3.ArrayUtils;

public class ArrayConcat {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        // 使用 ArrayUtils 拼接
        int[] result = ArrayUtils.addAll(array1, array2);

        // 输出结果
        for (int num : result) {
            System.out.print(num + " "); // 输出: 1 2 3 4 5 6
        }
    }
}

优点：

• 简洁高效。
• 支持基本类型数组和对象数组。

缺点：

• 需要引入外部库。

Maven 依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

---

6. 对比不同方法

方法	优点	缺点
System.arraycopy()	高效，适合需要性能的场景	使用稍显复杂，不如其他方法简洁
Arrays.copyOf()	语法简洁，适合拼接两个数组	不支持直接拼接多个数组
Streams.concat()	简洁优雅，支持对象数组	不适用于基本类型数组
手动拼接	灵活，可自定义逻辑	代码冗长，容易出错
ArrayUtils.addAll()	简洁，支持基本类型和对象数组	需要引入 Apache Commons Lang 外部库

---

7. 总结

• 性能优先 ：推荐使用 System.arraycopy()，它底层实现是高效的本地方法。
• 简洁性优先 ：推荐使用 Arrays.copyOf() 或 ArrayUtils.addAll()。
• 对象数组 ：推荐使用 Streams.concat()。
• 手动操作：适合需要灵活自定义逻辑的场景，但需注意代码维护性。

选择适合的拼接方法，可以根据代码的复杂度需求、性能要求和实际场景来权衡。