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

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

1. 浅拷贝(Shallow Copy)

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

示例代码:

java 复制代码
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)

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

示例代码:

java 复制代码
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对象。为了实现深拷贝,Personclone()方法不仅调用了super.clone(),还调用了Addressclone()方法。这样确保了Person对象的所有引用类型字段都被独立复制。

深拷贝的方式:

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

通过序列化实现深拷贝:

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()方法即为浅拷贝 较复杂,需要递归实现或使用序列化方式
应用场景 适用于对象引用的共享不会带来问题的场景 适用于需要深层次复制复杂对象的场景

4. 总结

  • 浅拷贝:仅复制对象本身,不复制其引用类型字段,导致原对象与拷贝对象共享引用。
  • 深拷贝:不仅复制对象本身,还会递归复制所有引用类型字段,实现完全独立的对象拷贝。

在实际开发中,选择浅拷贝还是深拷贝取决于对象的复杂度及引用的使用场景。如果需要确保对象和其引用对象的完全独立,则应使用深拷贝;而在不需要深层次对象复制的情况下,浅拷贝可以提高性能并减少内存开销。

相关推荐
Daniel 大东11 分钟前
idea 解决缓存损坏问题
java·缓存·intellij-idea
wind瑞18 分钟前
IntelliJ IDEA插件开发-代码补全插件入门开发
java·ide·intellij-idea
HappyAcmen18 分钟前
IDEA部署AI代写插件
java·人工智能·intellij-idea
马剑威(威哥爱编程)23 分钟前
读写锁分离设计模式详解
java·设计模式·java-ee
鸽鸽程序猿24 分钟前
【算法】【优选算法】前缀和(上)
java·算法·前缀和
修道-032325 分钟前
【JAVA】二、设计模式之策略模式
java·设计模式·策略模式
九圣残炎30 分钟前
【从零开始的LeetCode-算法】2559. 统计范围内的元音字符串数
java·算法·leetcode
当归102443 分钟前
若依项目-结构解读
java
hlsd#1 小时前
关于 SpringBoot 时间处理的总结
java·spring boot·后端
iiiiiankor1 小时前
C/C++内存管理 | new的机制 | 重载自己的operator new
java·c语言·c++