Java中的深拷贝与浅拷贝

在Java中，深拷贝和浅拷贝是两种不同的对象复制方式，主要区别在于它们如何处理对象内部的引用类型字段。

浅拷贝（Shallow Copy）

浅拷贝创建一个新对象，并将原对象的字段值复制到新对象中。如果字段是基本类型，则直接复制值；如果字段是引用类型，则复制引用（即内存地址），因此新对象和原对象共享相同的引用类型字段。

实现方式：

• 实现 Cloneable 接口并重写 clone() 方法。
• 使用工具类（如 BeanUtils.copyProperties）。

class Person implements Cloneable {
    String name;
    Address address;

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅拷贝
    }
}

class Address {
    String city;

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

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", address);
        Person person2 = (Person) person1.clone();

        System.out.println(person1.address == person2.address); // true，共享同一个Address对象
    }
}

深拷贝（Deep Copy）

深拷贝创建一个新对象，并递归地复制原对象的所有字段。如果字段是引用类型，则创建该字段的新副本，而不是共享引用。因此，新对象和原对象完全独立。
实现方式：

• 手动实现递归复制。
• 使用序列化（如 Serializable 接口）。
• 使用第三方库（如 Apache Commons Lang 的 SerializationUtils）。

• 如果对象包含循环引用，深拷贝需要特别处理，否则可能导致栈溢出。
• 序列化方式实现深拷贝要求所有相关类都实现 Serializable 接口。

import java.io.*;

class Person implements Serializable {
    String name;
    Address address;

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

    public Person deepCopy() throws IOException, ClassNotFoundException {
        // 使用序列化实现深拷贝
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Person) ois.readObject();
    }
}

class Address implements Serializable {
    String city;

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

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", address);
        Person person2 = person1.deepCopy();

        System.out.println(person1.address == person2.address); // false，Address对象是独立的
    }
}

对比

拓展知识

Java 中的 clone() 方法

• clone() 是 Object 类的一个方法，用于创建对象的副本。
• 默认的 clone() 方法是浅拷贝。
• 使用 clone() 需要满足以下条件：
  • 类必须实现 Cloneable 接口（标记接口，没有方法）。
  • 重写 clone() 方法，并将其访问修饰符改为 public。
• 注意：clone() 方法不会调用构造函数。

class Person implements Cloneable {
    String name;
    int age;

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

    @Override
    public Person clone() {
        try {
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

序列化实现深拷贝

通过序列化和反序列化可以实现深拷贝。但要求所有相关类都实现 Serializable 接口。

• 优点：简单易用，适合复杂对象图的深拷贝。
• 缺点：性能较低，且要求所有字段都可序列化。

import java.io.*;

class DeepCopyUtil {
    public static <T extends Serializable> T deepCopy(T object) {
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(bos)) {
            oos.writeObject(object);

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

深拷贝与不可变对象
如果对象是不可变的（如 String、Integer 等），则浅拷贝和深拷贝的效果相同。不可变对象的值无法被修改，因此共享引用是安全的。

String s1 = "Hello";
String s2 = s1; // 浅拷贝，但因为是不可变对象，所以安全

深拷贝的性能问题
深拷贝需要递归复制整个对象图，可能会消耗较多内存和 CPU 资源。如果对象图非常大或嵌套层级很深，深拷贝可能会导致性能问题。
优化方法：

• 使用懒加载（Lazy Copy）：只有在修改时才复制对象。
• 使用对象池或缓存机制。

深拷贝与线程安全

如果多个线程共享同一个对象，浅拷贝可能导致线程安全问题。深拷贝可以避免线程安全问题，因为每个线程操作的是独立的对象副本。