Java深拷贝与浅拷贝详细区别与实现

class Address implements Cloneable {
    String street;
    String city;

    public Address(String street, String city) {
        this.street = street;
        this.city = city;
    }

    // 复制构造函数
    public Address(Address other) {
        this.street = other.street;
        this.city = other.city;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // Address内部只有String，String是不可变的，所以浅拷贝即可
    }
}

class User implements Cloneable {
    String name;
    Address address;

    public User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    // 复制构造函数实现深拷贝
    public User(User other) {
        this.name = other.name;
        // 关键：对引用类型字段进行深拷贝
        this.address = new Address(other.address); 
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        User clonedUser = (User) super.clone(); // 浅拷贝
        // 关键：手动深拷贝引用类型字段
        clonedUser.address = (Address) address.clone(); 
        return clonedUser;
    }
}

import java.io.*;

public class DeepCopyUtil {
    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 (IOException | ClassNotFoundException e) {
            // 实际项目中需要更细致的异常处理
            throw new RuntimeException("深拷贝失败", e); 
        }
    }
}

// 示例类，需要实现Serializable
class Person implements Serializable {
    String name;
    Address address; // Address也需要实现Serializable

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

// Address也需要实现Serializable
class Address implements Serializable {
    String street;
    String city;

    public Address(String street, String city) {
        this.street = street;
        this.city = city;
    }
}

import java.util.ArrayList;
import java.util.List;

class Item {
    String name;
    public Item(String name) { this.name = name; }
    @Override public String toString() { return "Item{" + "name='" + name + '\'' + '}'; }
}

class Order {
    int orderId;
    List<Item> items; // 这是一个引用类型字段

    public Order(int orderId, List<Item> items) {
        this.orderId = orderId;
        this.items = items;
    }

    // 浅拷贝构造函数
    public Order(Order other) {
        this.orderId = other.orderId;
        this.items = other.items; // 浅拷贝：直接复制引用
    }
}

public class ShallowCopyRisk {
    public static void main(String[] args) {
        List<Item> originalItems = new ArrayList<>();
        originalItems.add(new Item("Laptop"));
        originalItems.add(new Item("Mouse"));

        Order originalOrder = new Order(1001, originalItems);
        System.out.println("原始订单商品: " + originalOrder.items);

        // 创建一个浅拷贝订单
        Order copiedOrder = new Order(originalOrder);
        copiedOrder.orderId = 1002; // 修改基本类型字段，没问题

        // 在拷贝订单中添加一个商品
        copiedOrder.items.add(new Item("Keyboard")); // 这里是关键！

        System.out.println("拷贝订单商品: " + copiedOrder.items);
        System.out.println("原始订单商品 (修改后): " + originalOrder.items); // 发现原始订单也被修改了！
    }
}