Java中数组array的复制方法

Java中提供了多种数组复制的方法，下面详细介绍各种方法及其使用场景。

1. 使用循环手动复制

// 基本数据类型数组
int[] source = {1, 2, 3, 4, 5};
int[] dest = new int[source.length];

for (int i = 0; i < source.length; i++) {
    dest[i] = source[i];
}

// 对象数组
String[] sourceStr = {"A", "B", "C"};
String[] destStr = new String[sourceStr.length];

for (int i = 0; i < sourceStr.length; i++) {
    destStr[i] = sourceStr[i]; // 浅拷贝
}

2. System.arraycopy()方法

int[] source = {1, 2, 3, 4, 5};
int[] dest = new int[5];

// 参数：源数组, 源起始位置, 目标数组, 目标起始位置, 复制长度
System.arraycopy(source, 0, dest, 0, source.length);

// 复制部分数组
int[] partialDest = new int[3];
System.arraycopy(source, 1, partialDest, 0, 3); // 复制2,3,4

3. Arrays.copyOf()方法

import java.util.Arrays;

int[] source = {1, 2, 3, 4, 5};

// 复制整个数组
int[] dest1 = Arrays.copyOf(source, source.length);

// 复制指定长度（可截断或填充默认值）
int[] dest2 = Arrays.copyOf(source, 3);  // [1,2,3]
int[] dest3 = Arrays.copyOf(source, 7);  // [1,2,3,4,5,0,0]

4. Arrays.copyOfRange()方法

import java.util.Arrays;

int[] source = {1, 2, 3, 4, 5};

// 复制指定范围的元素
// 参数：源数组, 起始索引(包含), 结束索引(不包含)
int[] dest = Arrays.copyOfRange(source, 1, 4); // [2,3,4]

5. clone()方法

int[] source = {1, 2, 3, 4, 5};
int[] dest = source.clone();

// 对象数组
String[] sourceStr = {"A", "B", "C"};
String[] destStr = sourceStr.clone();

6. 对象数组的深拷贝

import java.util.Arrays;

// 对于需要深拷贝的对象数组
class Person implements Cloneable {
    String name;
    
    public Person(String name) {
        this.name = name;
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

// 深拷贝实现
Person[] people = {new Person("Alice"), new Person("Bob")};
Person[] deepCopy = new Person[people.length];

try {
    for (int i = 0; i < people.length; i++) {
        deepCopy[i] = (Person) people[i].clone();
    }
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}

性能比较和使用场景

示例代码

import java.util.Arrays;

public class ArrayCopyDemo {
    public static void main(String[] args) {
        // 原始数组
        int[] original = {1, 2, 3, 4, 5};
        
        // 1. System.arraycopy
        int[] copy1 = new int[5];
        System.arraycopy(original, 0, copy1, 0, 5);
        System.out.println("System.arraycopy: " + Arrays.toString(copy1));
        
        // 2. Arrays.copyOf
        int[] copy2 = Arrays.copyOf(original, 5);
        System.out.println("Arrays.copyOf: " + Arrays.toString(copy2));
        
        // 3. Arrays.copyOfRange
        int[] copy3 = Arrays.copyOfRange(original, 1, 4);
        System.out.println("Arrays.copyOfRange: " + Arrays.toString(copy3));
        
        // 4. clone
        int[] copy4 = original.clone();
        System.out.println("clone: " + Arrays.toString(copy4));
        
        // 验证是否为深拷贝（对于基本类型数组）
        copy1[0] = 100;
        System.out.println("修改拷贝后原数组: " + Arrays.toString(original));
        System.out.println("修改后的拷贝: " + Arrays.toString(copy1));
    }
}

注意事项

1. 基本类型数组：所有方法都是深拷贝
2. 对象数组：所有方法都是浅拷贝，只复制引用
3. 数组边界：注意索引越界问题
4. 性能思考：对于大数据量，优先使用System.arraycopy()

选择哪种方法取决于具体需求：性能要求、是否需要部分复制、代码简洁性等。