Java中对象的深拷贝和浅拷贝实现方法

浅拷贝复制对象时仅复制基本类型值和引用地址，原对象与副本共享引用对象；深拷贝递归复制所有层级对象，确保完全独立。Java中可通过实现Cloneable接口进行浅拷贝，或通过递归clone、序列化反序列化、拷贝构造器等方式实现深拷贝。核心区别在于数据独立性：浅拷贝内存开销小但存在共享风险，适用于不可变对象或性能敏感场景；深拷贝适用于可变引用字段，避免副作用，常用于快照、数据隔离等场景。常见陷阱包括未实现Cloneable接口、遗漏引用字段深拷贝、Serializable缺失及transient字段处理不当等。

Java中对象的深拷贝和浅拷贝，本质上讲，是关于“复制”这个动作的深浅程度。浅拷贝仅仅复制了对象本身及其内部的原始类型字段值，而对于引用类型字段，它复制的只是这些字段的引用，而非引用指向的实际对象。这意味着，原对象和拷贝对象会共享同一份内部引用对象。深拷贝则不同，它不仅复制了对象本身，还会递归地复制其内部所有引用类型字段指向的对象，确保新旧对象在内存中完全独立，互不影响。选择哪种方式，往往取决于你对数据独立性的要求，以及对性能的考量。

解决方案

在Java中实现对象的深拷贝和浅拷贝，有几种常用的方法，每种都有其适用场景和需要注意的地方。我个人在项目中接触下来，发现理解它们背后的机制远比记住语法重要。

浅拷贝的实现

最直接的浅拷贝方式，往往是通过实现

Cloneable

接口并重写

Object

类的

clone()

方法来完成。

立即学习“Java免费学习笔记（深入）”；

class Address {    String city;    String street;    public Address(String city, String street) {        this.city = city;        this.street = street;    }    @Override    public String toString() {        return "Address{" + "city='" + city + ''' + ", street='" + street + ''' + '}';    }}class Employee implements Cloneable {    String name;    Address address; // 引用类型字段    public Employee(String name, Address address) {        this.name = name;        this.address = address;    }    @Override    protected Object clone() throws CloneNotSupportedException {        // Object.clone() 默认实现就是浅拷贝        return super.clone();    }    @Override    public String toString() {        return "Employee{" + "name='" + name + ''' + ", address=" + address + '}';    }}// 示例用法public class ShallowCopyDemo {    public static void main(String[] args) throws CloneNotSupportedException {        Address addr = new Address("Beijing", "Chaoyang Road");        Employee originalEmp = new Employee("Alice", addr);        Employee clonedEmp = (Employee) originalEmp.clone();        System.out.println("Original: " + originalEmp); // Original: Employee{name='Alice', address=Address{city='Beijing', street='Chaoyang Road'}}        System.out.println("Cloned:   " + clonedEmp);   // Cloned:   Employee{name='Alice', address=Address{city='Beijing', street='Chaoyang Road'}}        // 修改克隆对象的地址信息        clonedEmp.address.street = "Haidian Road";        System.out.println("After modification:");        System.out.println("Original: " + originalEmp); // Original: Employee{name='Alice', address=Address{city='Beijing', street='Haidian Road'}}        System.out.println("Cloned:   " + clonedEmp);   // Cloned:   Employee{name='Alice', address=Address{city='Beijing', street='Haidian Road'}}        // 可以看到，原对象的地址也跟着变了，这就是浅拷贝的“坑”    }}

这里，

Object.clone()

方法执行的就是浅拷贝。它会创建一个新对象，然后将原对象的所有字段值复制到新对象中。对于原始类型字段（如

int

,

boolean

等），是值复制；对于引用类型字段（如

Address

对象），复制的是引用本身，而不是引用指向的

Address

对象内容。所以，当修改

clonedEmp.address

时，

originalEmp.address

也受到了影响，因为它们指向的是同一个

Address

实例。

深拷贝的实现

深拷贝的目标是让拷贝对象与原对象完全独立。通常有以下几种策略：

递归实现

clone()

方法 (手动深拷贝)这是最直接，也是最能体现深拷贝原理的方式。你需要在父类和所有包含引用类型字段的子类中，递归地重写

clone()

方法，并在其中手动调用引用对象的

clone()

方法。

class Address implements Cloneable {    String city;    String street;    public Address(String city, String street) {        this.city = city;        this.street = street;    }    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone(); // Address类内部没有引用类型，所以浅拷贝即可    }    @Override    public String toString() {        return "Address{" + "city='" + city + ''' + ", street='" + street + ''' + '}';    }}class Employee implements Cloneable {    String name;    Address address;    public Employee(String name, Address address) {        this.name = name;        this.address = address;    }    @Override    protected Object clone() throws CloneNotSupportedException {        Employee clonedEmp = (Employee) super.clone(); // 先进行浅拷贝        // 对引用类型字段进行深拷贝        clonedEmp.address = (Address) this.address.clone();        return clonedEmp;    }    @Override    public String toString() {        return "Employee{" + "name='" + name + ''' + ", address=" + address + '}';    }}public class DeepCopyCloneDemo {    public static void main(String[] args) throws CloneNotSupportedException {        Address addr = new Address("Shanghai", "Pudong Road");        Employee originalEmp = new Employee("Bob", addr);        Employee clonedEmp = (Employee) originalEmp.clone();        System.out.println("Original: " + originalEmp);        System.out.println("Cloned:   " + clonedEmp);        clonedEmp.address.street = "Huangpu Road"; // 修改克隆对象的地址        System.out.println("After modification:");        System.out.println("Original: " + originalEmp); // Original: Employee{name='Bob', address=Address{city='Shanghai', street='Pudong Road'}}        System.out.println("Cloned:   " + clonedEmp);   // Cloned:   Employee{name='Bob', address=Address{city='Shanghai', street='Huangpu Road'}}        // 这次原对象的地址没变，实现了深拷贝    }}

通过序列化和反序列化实现这是实现深拷贝的一种“旁门左道”但非常有效的方式，尤其适用于对象图复杂、层级较深的情况。其原理是将对象写入一个输出流（序列化），然后再从输入流中读出（反序列化），这样得到的对象就是原对象的一个全新且独立的副本。

import java.io.*;class Address implements Serializable { // 必须实现Serializable接口    String city;    String street;    public Address(String city, String street) {        this.city = city;        this.street = street;    }    @Override    public String toString() {        return "Address{" + "city='" + city + ''' + ", street='" + street + ''' + '}';    }}class Employee implements Serializable { // 必须实现Serializable接口    String name;    Address address;    public Employee(String name, Address address) {        this.name = name;        this.address = address;    }    @Override    public String toString() {        return "Employee{" + "name='" + name + ''' + ", address=" + address + '}';    }}public class DeepCopySerializationDemo {    public static  T deepCopy(T obj) {        try {            ByteArrayOutputStream bos = new ByteArrayOutputStream();            ObjectOutputStream oos = new ObjectOutputStream(bos);            oos.writeObject(obj); // 序列化            oos.close();            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());            ObjectInputStream ois = new ObjectInputStream(bis);            T copiedObj = (T) ois.readObject(); // 反序列化            ois.close();            return copiedObj;        } catch (IOException | ClassNotFoundException e) {            throw new RuntimeException("Deep copy failed: " + e.getMessage(), e);        }    }    public static void main(String[] args) {        Address addr = new Address("Guangzhou", "Tianhe Road");        Employee originalEmp = new Employee("Charlie", addr);        Employee clonedEmp = deepCopy(originalEmp);        System.out.println("Original: " + originalEmp);        System.out.println("Cloned:   " + clonedEmp);        clonedEmp.address.street = "Yuexiu Road";        System.out.println("After modification:");        System.out.println("Original: " + originalEmp);        System.out.println("Cloned:   " + clonedEmp);        // 同样实现了深拷贝    }}

通过拷贝构造器或工厂方法这是一种更面向对象的设计模式，通过构造函数或静态工厂方法来创建对象的副本。它提供了更好的类型安全性和控制力。

class Address {    String city;    String street;    public Address(String city, String street) {        this.city = city;        this.street = street;    }    // 拷贝构造器    public Address(Address other) {        this.city = other.city;        this.street = other.street;    }    @Override    public String toString() {        return "Address{" + "city='" + city + ''' + ", street='" + street + ''' + '}';    }}class Employee {    String name;    Address address;    public Employee(String name, Address address) {        this.name = name;        this.address = address;    }    // 拷贝构造器    public Employee(Employee other) {        this.name = other.name;        // 对引用类型字段进行深拷贝        this.address = new Address(other.address);    }    @Override    public String toString() {        return "Employee{" + "name='" + name + ''' + ", address=" + address + '}';    }}public class DeepCopyConstructorDemo {    public static void main(String[] args) {        Address addr = new Address("Shenzhen", "Nanshan Road");        Employee originalEmp = new Employee("David", addr);        Employee clonedEmp = new Employee(originalEmp); // 使用拷贝构造器        System.out.println("Original: " + originalEmp);        System.out.println("Cloned:   " + clonedEmp);        clonedEmp.address.street = "Futian Road";        System.out.println("After modification:");        System.out.println("Original: " + originalEmp);        System.out.println("Cloned:   " + clonedEmp);        // 同样实现了深拷贝    }}

Java中浅拷贝与深拷贝的核心区别与适用场景是什么？

讲到深浅拷贝，我经常会想，这就像是复印文件。浅拷贝就好比你复印了一份文件的封面，而里面的内容（比如文件里夹着的一张照片）还是和原件共享的。你动了复印件里的照片，原件里的照片也会变。深拷贝呢，就是连同文件封面带里面的所有内容，包括那张照片，都完完整整地复印了一份新的，互不影响。

核心区别：

数据独立性： 这是最关键的。浅拷贝中，原始对象和拷贝对象会共享内部的引用类型对象。这意味着对拷贝对象内部引用对象的修改，会直接反映到原始对象上。而深拷贝则确保了所有层级的对象都是独立的副本，修改拷贝对象不会影响原始对象。内存占用： 浅拷贝只为顶层对象分配了新内存，内部引用对象仍然是共享的，所以内存开销相对较小。深拷贝需要为所有被复制的对象（包括嵌套对象）都分配新的内存，因此内存开销通常更大。实现复杂性： 浅拷贝通常通过

Object.clone()

或简单的字段赋值即可实现。深拷贝则需要根据对象结构的复杂性，选择递归

clone()

、序列化或拷贝构造器等方式，实现起来通常更复杂，尤其是当对象图非常深或存在循环引用时。

适用场景：

浅拷贝适用场景：

对象内部不包含引用类型字段，或者所有引用类型字段都是不可变（Immutable）的： 例如，一个只包含

String

、

Integer

等基本包装类和原始类型字段的对象。

String

虽然是引用类型，但它是不可变的，所以浅拷贝

String

引用，效果上等同于深拷贝。性能敏感的场景： 如果对象结构简单，且你明确知道不需要完全独立的副本，或者修改共享引用是可接受甚至期望的行为，浅拷贝能提供更好的性能。当你希望副本和原件共享部分状态时： 某些设计模式或特定业务逻辑可能要求对象的部分状态是共享的。

深拷贝适用场景：

当对象包含可变的引用类型字段时： 这是最常见的需求。例如，一个

Order

对象包含一个

List

，如果你希望修改拷贝

Order

的

List

不会影响原始

Order

，就必须使用深拷贝。需要完全独立的数据副本，避免副作用： 比如，你在处理一个复杂的数据结构，需要对其进行一系列操作，但又不想破坏原始数据，这时深拷贝就必不可少。实现“快照”功能： 捕获对象在某一时刻的状态，以便后续恢复或比较。

我个人在项目中，如果不是明确知道对象内部都是不可变类型，或者有特殊共享需求，我通常会倾向于深拷贝。因为浅拷贝带来的“副作用”往往是隐蔽的，在后期维护时可能导致难以追踪的bug。

如何在Java中实现自定义对象的深拷贝，有哪些常见陷阱？

实现自定义对象的深拷贝，我刚才提到了几种方法，每种都有其“脾气”和需要注意的坑。没有银弹，只有最适合你当前场景的方案。

实现方法回顾：

递归实现

Cloneable

clone()

方法：

核心思想： 在每个需要深拷贝的类中，都实现

Cloneable

接口，并重写

protected Object clone()

方法。在重写的方法中，首先调用

super.clone()

获取一个浅拷贝，然后对所有引用类型字段，递归地调用它们的

clone()

方法，并将返回的新对象赋值给当前对象的对应字段。示例： 之前展示的

Employee

和

Address

类的例子。

通过序列化和反序列化：

核心思想： 将对象及其所有可序列化的内部对象写入一个

ByteArrayOutputStream

，再从

ByteArrayInputStream

中读出。这个过程会创建所有对象的新实例。示例： 之前展示的

deepCopy

泛型方法。

通过拷贝构造器或工厂方法：

核心思想： 为需要拷贝的类提供一个特殊的构造器，它接受一个同类型的对象作为参数。在这个构造器中，手动复制所有字段，对于引用类型字段，则调用其自身的拷贝构造器或工厂方法来创建新实例。示例： 之前展示的

Employee(Employee other)

构造器。

常见陷阱：

clone()

方法实现中的陷阱：

未实现

Cloneable

接口：

Cloneable

是一个标记接口，如果一个类没有实现它，但调用了

Object.clone()

，会抛出

CloneNotSupportedException

。很多人会忘记让所有参与拷贝的类都实现这个接口。未调用

super.clone()

：

Object.clone()

是本地方法，负责对象的内存分配和原始字段的复制。如果你直接

new

一个新对象，就失去了

clone()

的语义，而且还需要手动复制所有字段，容易出错。忘记对引用类型字段进行递归深拷贝： 这是最常见的错误，直接导致深拷贝变成了浅拷贝。尤其在对象结构复杂时，容易遗漏某个字段。

Object.clone()

的访问修饰符：

Object.clone()

是

protected

的，这意味着你只能在同一个包内或子类中直接调用它。通常，我们会将重写的

clone()

方法声明为

public

，方便外部调用。

CloneNotSupportedException

的处理： 由于

Object.clone()

声明抛出此异常，你重写时也需要处理或声明抛出。

序列化/反序列化实现中的陷阱：

未实现

Serializable

接口： 所有参与序列化拷贝的对象（包括其内部所有引用对象）都必须实现

Serializable

接口，否则会抛出

NotSerializableException

。

transient

关键字： 被

transient

修饰的字段在序列化时会被忽略，这意味着它们不会被拷贝。如果你需要拷贝这些字段，就不能用

transient

修饰，或者需要自定义序列化逻辑（例如，通过实现

Externalizable

接口或提供

writeObject

/

readObject

方法）。性能开销： 序列化/反序列化过程涉及IO操作，通常比直接的

clone()

或拷贝构造器要慢。对于性能要求极高的场景，可能需要慎重考虑。版本兼容性： 如果序列化的字节流被长期存储或在不同版本的应用之间传输，

serialVersionUID

的管理变得很重要，否则可能出现

InvalidClassException

。不过，对于简单的内存深拷贝，这通常不是大问题。

拷贝构造器实现中的陷阱：

遗漏字段： 拷贝构造器需要手动复制所有字段。如果后期新增了字段，而忘记更新拷贝构造器，那么新字段将不会被拷贝，可能导致数据不一致。未对引用类型字段进行深拷贝： 和

clone()

一样，

以上就是Java中对象的深拷贝和浅拷贝实现方法的详细内容，更多请关注创想鸟其它相关文章！