Java实现数组的复制及深浅拷贝的常见方法总结

int[] original = {1, 2, 3, 4, 5};
int[] shallowCopy = original;  // 只是引用复制

original[0] = 100;
System.out.println(shallowCopy[0]);  // 输出 100，两个数组指向同一对象

// 对于基本类型数组，clone() 是深拷贝
int[] original = {1, 2, 3, 4, 5};
int[] copy = original.clone();

original[0] = 100;
System.out.println(copy[0]);  // 输出 1，因为是基本类型数组

// 对于对象数组，clone() 是浅拷贝
Person[] persons = {new Person("Alice"), new Person("Bob")};
Person[] shallowCopy = persons.clone();

persons[0].setName("Charlie");
System.out.println(shallowCopy[0].getName());  // 输出 "Charlie"

int[] original = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(original, original.length);

// 对于对象数组
Person[] persons = {new Person("Alice"), new Person("Bob")};
Person[] shallowCopy = Arrays.copyOf(persons, persons.length);

int[] original = {1, 2, 3, 4, 5};
int[] copy = new int[original.length];
System.arraycopy(original, 0, copy, 0, original.length);

// 对于对象数组
class Person implements Cloneable {
    private String name;

    public Person(String name) { this.name = name; }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();  // 假设 Person 是浅拷贝可接受的
        // 或者返回 new Person(this.name);  // 深拷贝
    }
}

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

for (int i = 0; i < original.length; i++) {
    // 假设 Person 类有合适的拷贝构造方法
    deepCopy[i] = new Person(original[i].getName());
    // 或者使用 clone()
    // deepCopy[i] = (Person) original[i].clone();
}

import java.io.*;

public class DeepCopyUtil {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T deepCopy(T obj) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(obj);
            oos.flush();

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (T) ois.readObject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

// 使用
Person[] persons = {new Person("Alice"), new Person("Bob")};
Person[] deepCopy = deepCopy(persons);

// 添加依赖：org.apache.commons:commons-lang3
import org.apache.commons.lang3.SerializationUtils;

// 对象必须实现 Serializable
Person[] persons = {new Person("Alice"), new Person("Bob")};
Person[] deepCopy = SerializationUtils.clone(persons);

// 二维数组深拷贝
int[][] original = {{1, 2}, {3, 4}};
int[][] deepCopy = new int[original.length][];

for (int i = 0; i < original.length; i++) {
    deepCopy[i] = original[i].clone();  // 对于基本类型数组有效
}

// 对象二维数组
Person[][] persons = {{new Person("Alice")}, {new Person("Bob")}};
Person[][] deepCopy = new Person[persons.length][];

for (int i = 0; i < persons.length; i++) {
    deepCopy[i] = new Person[persons[i].length];
    for (int j = 0; j < persons[i].length; j++) {
        deepCopy[i][j] = new Person(persons[i][j].getName());
    }
}

import java.util.Arrays;

// 对象数组深拷贝（需要合适的构造方法）
Person[] original = {new Person("Alice"), new Person("Bob")};
Person[] deepCopy = Arrays.stream(original)
    .map(p -> new Person(p.getName()))
    .toArray(Person[]::new);