Java中的深拷贝与浅拷贝详解

Y雨何时停T

已于 2024-09-10 07:51:09 修改

阅读量347

点赞数 11

分类专栏： Java 文章标签： java

于 2024-09-10 07:42:09 首次发布

本文链接：https://blog.csdn.net/m0_64432106/article/details/142074365

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

在Java开发中，理解对象的深拷贝与浅拷贝是非常重要的。这两种拷贝方式决定了对象在内存中是如何被复制的，以及它们对原对象的引用与数据的影响。本文将详细介绍深拷贝与浅拷贝的概念、区别以及如何在Java中实现它们。

1. 浅拷贝（Shallow Copy）

浅拷贝是指对象的字段会被复制，但如果字段是对其他对象的引用，那么拷贝后的对象与原对象将共享这些引用。也就是说，对象中的所有引用类型字段并没有被真正复制，它们仍然指向同一个内存地址。

示例代码：

class Person implements Cloneable {
    String name;
    int age;

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();  // 默认实现的clone()方法为浅拷贝
    }
}

public class ShallowCopyExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person original = new Person("John", 25);
        Person shallowCopy = (Person) original.clone();

        System.out.println("Original name: " + original.name); // John
        System.out.println("Shallow copy name: " + shallowCopy.name); // John

        shallowCopy.name = "Doe";
        System.out.println("After modification:");
        System.out.println("Original name: " + original.name); // John
        System.out.println("Shallow copy name: " + shallowCopy.name); // Doe
    }
}

解释：

在上述代码中，Person类实现了Cloneable接口，并重写了clone()方法。浅拷贝后的对象shallowCopy中的name字段与原始对象中的name字段指向的是同一内存地址。因此，修改shallowCopy中的name会影响原对象中的name字段。

注意：

基本数据类型：浅拷贝时，基本数据类型字段会被直接复制，拷贝对象和原对象的值是独立的。
引用类型：引用类型字段在浅拷贝时不会创建新对象，原对象与拷贝对象共用同一个引用对象。

2. 深拷贝（Deep Copy）

深拷贝与浅拷贝的不同之处在于：深拷贝不仅复制对象本身，还会递归地复制对象所引用的其他对象。也就是说，深拷贝会创建一个独立的对象副本，拷贝后的对象和原对象不会共享内存中的引用。

示例代码：

class Address implements Cloneable {
    String city;

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Person implements Cloneable {
    String name;
    int age;
    Address address;

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        cloned.address = (Address) address.clone();  // 递归拷贝引用类型
        return cloned;
    }
}

public class DeepCopyExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("New York");
        Person original = new Person("John", 25, address);
        Person deepCopy = (Person) original.clone();

        System.out.println("Original city: " + original.address.city); // New York
        System.out.println("Deep copy city: " + deepCopy.address.city); // New York

        deepCopy.address.city = "Los Angeles";
        System.out.println("After modification:");
        System.out.println("Original city: " + original.address.city); // New York
        System.out.println("Deep copy city: " + deepCopy.address.city); // Los Angeles
    }
}

解释：

在这个例子中，Person对象包含一个引用类型的Address对象。为了实现深拷贝，Person的clone()方法不仅调用了super.clone()，还调用了Address的clone()方法。这样确保了Person对象的所有引用类型字段都被独立复制。

深拷贝的方式：

递归调用clone()：如上例所示，递归地调用所有引用对象的clone()方法，实现对复杂对象的完全复制。
序列化与反序列化：另一种常用的深拷贝方法是通过Java的序列化机制，将对象序列化为字节流，再反序列化为新对象。这种方式可以确保对象的完整复制。

通过序列化实现深拷贝：

import java.io.*;

class Address implements Serializable {
    String city;

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

class Person implements Serializable {
    String name;
    int age;
    Address address;

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

public class DeepCopyWithSerialization {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Address address = new Address("New York");
        Person original = new Person("John", 25, address);

        // 序列化对象
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(original);

        // 反序列化对象
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        Person deepCopy = (Person) ois.readObject();

        System.out.println("Original city: " + original.address.city); // New York
        System.out.println("Deep copy city: " + deepCopy.address.city); // New York

        deepCopy.address.city = "Los Angeles";
        System.out.println("After modification:");
        System.out.println("Original city: " + original.address.city); // New York
        System.out.println("Deep copy city: " + deepCopy.address.city); // Los Angeles
    }
}

解释：

通过Java序列化机制，我们可以将对象完全拷贝为独立的对象实例。序列化将对象转化为字节流，反序列化会生成一个新的对象副本，从而实现深拷贝。

3. 深拷贝与浅拷贝的比较

特性	浅拷贝	深拷贝
拷贝方式	只拷贝对象本身和基本类型字段	拷贝对象本身及其所有引用对象
引用共享	原对象和拷贝对象共享引用类型字段的引用地址	原对象和拷贝对象完全独立
实现复杂度	较简单，默认实现的`clone()`方法即为浅拷贝	较复杂，需要递归实现或使用序列化方式
应用场景	适用于对象引用的共享不会带来问题的场景	适用于需要深层次复制复杂对象的场景