17370845950

新闻动态

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

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

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

解决方案

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

浅拷贝的实现

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

Cloneable

接口并重写

Object

类的

clone()

方法来完成。

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()
```
  一样，

17370845950

解决方案

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

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

关于我们

服务项目

广告推广

案例欣赏