Java集合深拷贝浅拷贝

在Java中，对象的拷贝可以分为两种：浅拷贝（Shallow Copy）和深拷贝（Deep Copy）。这两种拷贝方式的主要区别在于它们处理对象内部引用类型字段的方式。

1. 浅拷贝（Shallow Copy）： 浅拷贝创建一个新对象，这个新对象有着和原始对象完全相同的值（对于基本数据类型）或者引用（对于引用数据类型）。换句话说，如果字段是基本数据类型，则直接复制其值；如果字段是引用数据类型，则复制的是引用，而不是对象本身。这意味着，如果原始对象中的引用数据类型字段指向的对象发生变化，那么浅拷贝后的对象中的对应字段也会受到影响。

在Java中，可以通过以下方式实现浅拷贝：

• 使用对象的拷贝构造函数。
• 使用clone()方法（前提是实现了Cloneable接口）。

示例：

class ShallowCopyExample implements Cloneable {
    int value;
    List<String> list;

    public ShallowCopyExample(int value, List<String> list) {
        this.value = value;
        this.list = list;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

// 创建一个对象
ShallowCopyExample original = new ShallowCopyExample(1, new ArrayList<>(Arrays.asList("A", "B")));

// 创建一个浅拷贝
ShallowCopyExample copy = (ShallowCopyExample) original.clone();

// 修改原始对象的list
original.list.add("C");

// 输出原始对象和拷贝对象的list
System.out.println(original.list); // 输出：[A, B, C]
System.out.println(copy.list); // 输出：[A, B]

2. 深拷贝（Deep Copy）： 深拷贝创建一个新对象，并递归地复制原始对象中的所有字段。对于基本数据类型，直接复制其值；对于引用数据类型，复制的是对象本身，而不是引用。这意味着，即使原始对象中的引用数据类型字段指向的对象发生变化，深拷贝后的对象中的对应字段也不会受到影响。

在Java中，可以通过以下方式实现深拷贝：

• 使用序列化和反序列化的方式。首先将对象序列化为字节数组，然后再将字节数组反序列化为一个新的对象。

示例：

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class DeepCopyExample implements Serializable {
    int value;
    List<String> list;

    public DeepCopyExample(int value, List<String> list) {
        this.value = value;
        this.list = list;
    }
}

public class DeepCopyExampleDemo {
    public static <T extends Serializable> T deepCopy(T obj) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(obj);

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            return (T) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException("Deep copy failed", e);
        }
    }

    public static void main(String[] args) {
        // 创建一个对象
        DeepCopyExample original = new DeepCopyExample(1, new ArrayList<>(Arrays.asList("A", "B")));

        // 创建一个深拷贝
        DeepCopyExample copy = deepCopy(original);

        // 修改原始对象的list
        original.list.add("C");

        // 输出原始对象和拷贝对象的list
        System.out.println(original.list); // 输出：[A, B, C]
        System.out.println(copy.list); // 输出：[A, B]
    }
}

总结：浅拷贝只复制对象的引用，而深拷贝会递归地复制对象及其内部的所有对象。在实际应用中，根据需求选择合适的拷贝方式。