Java 深度复制对象：从基础到实战

news2025/3/9 16:28:57

在 Java 编程中，对象的复制是一个常见的需求。然而，简单的复制操作（如直接赋值）只会复制对象的引用，而不是创建一个新的对象。这意味着两个引用会指向同一个内存地址，修改其中一个对象会影响另一个对象。为了解决这个问题，我们需要实现对象的深度复制。本文将详细介绍如何在 Java 中实现对象的深度复制，并通过具体代码示例帮助你更好地理解和应用这一技术。

一、深度复制的概念

深度复制是指创建一个新对象，并将原对象的所有字段值复制到新对象中。如果字段是基本数据类型，则直接复制其值；如果字段是引用类型，则需要递归地创建该引用对象的深度副本。这样可以确保新对象与原对象在内存中完全独立，修改其中一个不会影响另一个。

二、实现深度复制的方法

1. 使用序列化

Java 的序列化机制可以将对象转换为字节流，然后再将字节流还原为对象。这一过程实际上创建了一个对象的深度副本。

import java.io.*;

public class DeepCloneExample implements Serializable {
    private String name;
    private TransientData transientData;

    public DeepCloneExample(String name, TransientData transientData) {
        this.name = name;
        this.transientData = transientData;
    }

    public String getName() {
        return name;
    }

    public TransientData getTransientData() {
        return transientData;
    }

    @Override
    public String toString() {
        return "DeepCloneExample{" +
                "name='" + name + '\'' +
                ", transientData=" + transientData +
                '}';
    }

    public static DeepCloneExample deepClone(DeepCloneExample obj) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(obj);
        objectOutputStream.close();

        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        DeepCloneExample clonedObj = (DeepCloneExample) objectInputStream.readObject();
        objectInputStream.close();

        return clonedObj;
    }
}

class TransientData implements Serializable {
    private int value;

    public TransientData(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "TransientData{" +
                "value=" + value +
                '}';
    }
}

2. 手动实现深度复制

对于某些复杂对象，手动实现深度复制可能更高效。这需要为每个需要复制的对象编写自定义的 clone 方法。

public class DeepCopyExample {
    private int id;
    private String name;
    private Address address;

    public DeepCopyExample(int id, String name, Address address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }

    public DeepCopyExample deepCopy() {
        Address copiedAddress = new Address(this.address.getStreet(), this.address.getCity());
        return new DeepCopyExample(this.id, this.name, copiedAddress);
    }

    @Override
    public String toString() {
        return "DeepCopyExample{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address=" + address +
                '}';
    }

    public static void main(String[] args) {
        Address originalAddress = new Address("123 Main St", "Anytown");
        DeepCopyExample original = new DeepCopyExample(1, "Example", originalAddress);

        DeepCopyExample copy = original.deepCopy();

        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);

        original.getAddress().setCity("New City");
        System.out.println("After changing original's address city:");
        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);
    }
}

class Address {
    private String street;
    private String city;

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

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "street='" + street + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}