java arraycopy() 方法 详解

Java System.arraycopy() 方法详解

System.arraycopy() 是 Java 提供的一种高效数组操作方法，用于从一个数组复制部分或全部元素到另一个数组中。它由 java.lang.System 类提供，并直接调用底层的本地代码实现，因此性能非常高。

方法签名

public static void arraycopy(
    Object src,     // 源数组
    int srcPos,     // 源数组的起始位置
    Object dest,    // 目标数组
    int destPos,    // 目标数组的起始位置
    int length      // 要复制的元素个数
)

参数说明

1. src：

   • 源数组，从中复制数据。

2. srcPos：

   • 源数组的起始位置，表示从哪个索引开始复制（索引从 0 开始）。

3. dest：

   • 目标数组，将数据复制到该数组中。

4. destPos：

   • 目标数组的起始位置，表示将数据粘贴到目标数组的哪个索引位置。

5. length：

   • 要复制的元素个数。

使用规则和注意事项

1. 类型匹配：

   • 源数组和目标数组必须是相同类型或兼容类型。
   • 例如：可以从 int[] 复制到 int[]，但不能从 int[] 复制到 double[]。

2. 数组边界：

   • 确保复制的范围合法，否则会抛出 ArrayIndexOutOfBoundsException。
   • 示例：srcPos + length 和 destPos + length 必须分别小于源数组和目标数组的长度。

3. 深拷贝 vs 浅拷贝：

   • 该方法是浅拷贝：
     • 对于基本类型，直接复制值。
     • 对于引用类型，复制的是引用，而非对象本身。

4. 异常：

   • 如果源或目标数组为 null，会抛出 NullPointerException。
   • 如果类型不兼容，会抛出 ArrayStoreException。

示例代码

1. 基本用法

import java.util.Arrays;

public class ArrayCopyExample {
    public static void main(String[] args) {
        int[] source = {1, 2, 3, 4, 5};
        int[] destination = new int[10];

        // 将 source 数组的前 3 个元素复制到 destination，从索引 0 开始粘贴
        System.arraycopy(source, 0, destination, 0, 3);

        System.out.println("Source Array: " + Arrays.toString(source));
        System.out.println("Destination Array: " + Arrays.toString(destination));
    }
}

输出：

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

2. 复制部分元素

import java.util.Arrays;

public class PartialCopyExample {
    public static void main(String[] args) {
        String[] source = {"A", "B", "C", "D", "E"};
        String[] destination = new String[5];

        // 将 source 的第 2 和 3 个元素复制到 destination 的索引 1 和 2
        System.arraycopy(source, 1, destination, 1, 2);

        System.out.println("Source Array: " + Arrays.toString(source));
        System.out.println("Destination Array: " + Arrays.toString(destination));
    }
}

输出：

Source Array: [A, B, C, D, E]
Destination Array: [null, B, C, null, null]

3. 浅拷贝示例

public class ShallowCopyExample {
    public static void main(String[] args) {
        String[] source = {"A", "B", "C"};
        String[] destination = new String[3];

        // 浅拷贝
        System.arraycopy(source, 0, destination, 0, source.length);

        // 修改源数组中的第一个元素
        source[0] = "X";

        // 源数组和目标数组均受到影响
        System.out.println("Source Array: " + java.util.Arrays.toString(source));
        System.out.println("Destination Array: " + java.util.Arrays.toString(destination));
    }
}

输出：

Source Array: [X, B, C]
Destination Array: [X, B, C]

解释：由于是浅拷贝，修改源数组的引用会影响目标数组。

4. 合并数组

import java.util.Arrays;

public class MergeArrayExample {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};
        int[] mergedArray = new int[array1.length + array2.length];

        // 复制 array1 到 mergedArray 的前部分
        System.arraycopy(array1, 0, mergedArray, 0, array1.length);
        // 复制 array2 到 mergedArray 的后部分
        System.arraycopy(array2, 0, mergedArray, array1.length, array2.length);

        System.out.println("Merged Array: " + Arrays.toString(mergedArray));
    }
}

输出：

Merged Array: [1, 2, 3, 4, 5, 6]

与其他数组复制方法的对比

1. for 循环

• 实现：逐个复制每个元素。
• 优点：更灵活，适用于复杂的复制逻辑。
• 缺点：性能较低，代码冗长。

2. Arrays.copyOf()

• 实现：复制整个数组或部分数组，返回一个新数组。
• 优点：简单易用。
• 缺点：无法将数据复制到现有数组。

示例：

int[] source = {1, 2, 3};
int[] destination = Arrays.copyOf(source, source.length);

3. System.arraycopy()

• 实现：调用本地代码，高效复制。
• 优点：性能最佳，可将数据复制到现有数组。
• 缺点：需要明确起始位置和长度，灵活性稍差。

常见异常

1. ArrayIndexOutOfBoundsException：

   • 当 srcPos + length 超过源数组长度，或 destPos + length 超过目标数组长度时。

2. NullPointerException：

   • 如果源数组或目标数组为 null。

3. ArrayStoreException：

   • 当源数组和目标数组类型不兼容时。

性能和适用场景

1. 性能：

   • System.arraycopy() 的性能优于手动 for 循环，适用于大规模数组操作。

2. 适用场景：

   • 数组合并。
   • 数组部分复制。
   • 实现队列、栈等数据结构的扩容。

总结

• System.arraycopy() 是一个高效的数组复制方法，适合对数组内容进行部分或全部复制。
• 它支持浅拷贝，且要求源数组和目标数组的类型兼容。
• 在需要处理大量数组数据时，System.arraycopy() 是性能最佳的选择。