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. 总结

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

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

相关推荐
程序leo源1 小时前
C语言:操作符详解1
android·java·c语言·c++·青少年编程·c#
轮到我狗叫了2 小时前
栈的应用,力扣394.字符串解码力扣946.验证栈序列力扣429.N叉树的层序遍历力扣103.二叉树的锯齿形层序遍历
java·算法·leetcode
冰之杍3 小时前
Vscode进行Java开发环境搭建
java·ide·vscode
跳动的梦想家h6 小时前
黑马点评 秒杀下单出现的问题:服务器异常---java.lang.NullPointerException: null(已解决)
java·开发语言·redis
苹果醋36 小时前
前端面试之九阴真经
java·运维·spring boot·mysql·nginx
哎呦没7 小时前
Spring Boot OA:企业办公自动化的高效路径
java·spring boot·后端
真心喜欢你吖7 小时前
Spring Boot与MyBatis-Plus的高效集成
java·spring boot·后端·spring·mybatis
2402_857589367 小时前
企业办公自动化:Spring Boot OA管理系统开发与实践
java·spring boot·后端
G丶AEOM7 小时前
JVM逃逸分析机制
java·jvm
无聊写博客7 小时前
JDK、JRE、JVM的区别
java·开发语言·jvm