Java中的深拷贝和浅拷贝介绍

最新推荐文章于 2024-06-07 00:50:21 发布
最新推荐文章于 2024-06-07 00:50:21 发布
阅读量942 收藏 2
点赞数
分类专栏： java基础 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiang_wang01/article/details/130936503
版权
文章介绍了Java中的深拷贝和浅拷贝概念，通过实例展示了如何使用`clone()`方法实现对象拷贝。浅拷贝只复制对象的引用，导致对引用对象的修改会影响原对象。深拷贝则为引用类型创建新的内存空间，确保修改不会互相影响。文章还提到了序列化作为实现深拷贝的一种方式。
摘要由CSDN通过智能技术生成

文章目录

在讲解什么是深拷贝和浅拷贝之前，我们先来了解一下什么是基本类型和引用类型。

基本类型和引用类型

基本类型也称为值类型，分别是字符类型 char，布尔类型 boolean以及数值类型 byte、short、int、long、float、double。

引用类型则包括类、接口、数组、枚举等。

Java 将内存空间分为堆和栈。基本类型直接在栈中存储数值，而引用类型是将引用放在栈中，实际存储的值是放在堆中，通过栈中的引用指向堆中存放的数据。

在这里插入图片描述

上图定义的 a 和 b 都是基本类型，其值是直接存放在栈中的；而 c 和 d 是 String 声明的，这是一个引用类型，引用地址是存放在 栈中，然后指向堆的内存空间。

下面 d = c；这条语句表示将 c 的引用赋值给 d，那么 c 和 d 将指向同一块堆内存空间。

Clone方法

本篇博客我们讲解的是 Java 的深拷贝和浅拷贝，其实现方式正是通过调用 Object 类的 clone() 方法来完成。在 Object.class 类中，源码为：

protected native Object clone() throws CloneNotSupportedException;

这是一个用 native 关键字修饰的方法，只需要知道用 native 修饰的方法就是告诉操作系统，这个方法我不实现了，让操作系统去实现。具体怎么实现我们不需要了解，只需要知道 clone方法的作用就是复制对象，产生一个新的对象。

浅拷贝

浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制资源。

实现对象拷贝的类，需要实现 Cloneable 接口，并覆写 clone() 方法。

public class Address {

    private String province;
    private String city;

    public void setAddress(String province, String city) {
        this.province = province;
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address [province=" + province + ", city=" + city + "]";
    }
}

public class Student implements Cloneable {

    private String name;
    private int age;
    private Address address;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setAddress(String province, String city) {
        address.setAddress(province, city);
    }

    public void display(String name) {
        System.out.println(name + ":" + "name=" + name + ", age=" + age + "," + address);
    }

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

这是一个我们要进行赋值的原始类 Student。下面我们产生一个 Student对象，并调用其 clone 方法复制一个新的对象。

注意：调用对象的 clone 方法，必须要让类实现 Cloneable 接口，并且覆写 clone 方法。

测试：

    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student("小明",20);
        s1.setAddress("安徽","合肥");
        Student s2 = (Student) s1.clone();
        System.out.println("S1:"+s1);
        System.out.println("s1.getName:"+s1.getName().hashCode());
        System.out.println("S2:"+s2);
        System.out.println("s2.getName:"+s2.getName().hashCode());

        s1.display("s1");
        s2.display("s2");
        s2.setAddress("安徽","安庆");
        s1.display("s1");
        s2.display("s2");
    }

输出结果：

S1:org.example.jvm.Student@2a84aee7
s1.getName:756703
S2:org.example.jvm.Student@a09ee92
s2.getName:756703
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=合肥]
s1:name=s1, age=20,Address [province=安徽, city=安庆]
s2:name=s2, age=20,Address [province=安徽, city=安庆]

首先我们创建一个Student类的对象 s1，其name 为小明,age为20，地址类 Address 两个属性为 安徽和合肥。接着我们调用 clone() 方法复制另一个对象 s2，接着打印这两个对象的内容。

分析结果：

  • 从第 1 行和第 3 行打印结果来看，这是两个不同的对象。

  • 从第 5 行和第 6 行打印的对象内容看，原对象 s1 和克隆出来的对象 s2 内容完全相同。

  • 我们更改一下克隆对象 s2 的属性 Address 为安徽安庆（原对象 s1 是安徽合肥），但是从第 7 行和第 8 行打印结果来看，原对象 s1 和克隆对象 s2 的 Address 属性都被修改了。

  • 对象 Student 的属性 Address，经过 clone 之后，其实只是复制了其引用，他们指向的还是同一块堆内存空间，当修改其中一个对象的属性 Address，另一个也会跟着变化。

在这里插入图片描述

浅拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。

深拷贝

深拷贝，在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。

在这里插入图片描述

对于 Student 的引用类型的成员变量 Address ，需要实现 Cloneable 并重写 clone() 方法。

public class Address implements Cloneable{

    private String province;
    private String city;

    public void setAddress(String province, String city) {
        this.province = province;
        this.city = city;
    }

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

    @Override
    public String toString() {
        return "Address [province=" + province + ", city=" + city + "]";
    }
}

在 Student 的 clone() 方法中，需要拿到拷贝自己后产生的新的对象，然后对新的对象的引用类型再调用拷贝操作，实现对引用类型成员变量的深拷贝。

public class Student implements Cloneable {

    private String name;
    private int age;
    private Address address;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setAddress(String province, String city) {
        address.setAddress(province, city);
    }

    public void display(String name) {
        System.out.println(name + ":" + "name=" + name + ", age=" + age + "," + address);
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student s = (Student) super.clone();
        s.address = (Address) address.clone();
        return s;
    }
}

测试：

    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student("小明",20);
        s1.setAddress("安徽","合肥");
        Student s2 = (Student) s1.clone();
        System.out.println("S1:"+s1);
        System.out.println("s1.getName:"+s1.getName().hashCode());
        System.out.println("S2:"+s2);
        System.out.println("s2.getName:"+s2.getName().hashCode());

        s1.display("s1");
        s2.display("s2");
        s2.setAddress("安徽","安庆");
        s1.display("s1");
        s2.display("s2");
    }

输出结果：

S1:org.example.jvm.Student@2a84aee7
s1.getName:756703
S2:org.example.jvm.Student@a09ee92
s2.getName:756703
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=合肥]
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=安庆]

由输出结果可知，深拷贝后，不管是基础数据类型还是引用类型的成员变量，修改其值都不会相互造成影响。

注意：

但是这种做法有个弊端，这里我们Student类只有一个Address引用类型，而 Address 类没有，所以我们只用重写 Address 类的clone方法，但是如果 Address 类也存在一个引用类型，那么我们也要重写其clone方法，这样下去，有多少个引用类型，我们就要重写多少次，如果存在很多引用类型，那么代码量显然会很大，所以这种方法不太合适。

还有一种方式可以实现深拷贝：利用序列化

序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。

这里写到流中的对象则是原始对象的一个拷贝，因为原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。

注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。

public class Address implements Serializable {

    private String province;
    private String city;

    public void setAddress(String province, String city) {
        this.province = province;
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address [province=" + province + ", city=" + city + "]";
    }
}

public class Student implements Serializable {

    private String name;
    private int age;
    private Address address;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setAddress(String province, String city) {
        address.setAddress(province, city);
    }

    public void display(String name) {
        System.out.println(name + ":" + "name=" + name + ", age=" + age + "," + address);
    }

    //深度拷贝
    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

}

测试：

    public static void main(String[] args) throws Exception {
        Student s1 = new Student("小明",20);
        s1.setAddress("安徽","合肥");
        Student s2 = (Student) s1.deepClone();
        System.out.println("S1:"+s1);
        System.out.println("s1.getName:"+s1.getName().hashCode());
        System.out.println("S2:"+s2);
        System.out.println("s2.getName:"+s2.getName().hashCode());

        s1.display("s1");
        s2.display("s2");
        s2.setAddress("安徽","安庆");
        s1.display("s1");
        s2.display("s2");
    }

输出结果：

S1:org.example.jvm.Student@3f99bd52
s1.getName:756703
S2:org.example.jvm.Student@1f17ae12
s2.getName:756703
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=合肥]
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=安庆]

因为序列化产生的是两个完全独立的对象，所有无论嵌套多少个引用类型，序列化都是能实现深拷贝的。

小结

至此，相信什么是深拷贝，什么是浅拷贝，相信你一定明白了。

初念初恋
关注
专栏目录
Java实现内存拷贝函数功能
TechWhiz的博客
09-15 201
在Java中，没有直接提供内存拷贝函数（类似于C语言中的memcpy函数）。然而，我们可以通过使用数组的复制方法来实现类似的功能。本文将介绍如何在Java中实现内存拷贝函数，并提供相应的源代码示例。要实现内存拷贝功能，我们需要创建一个新的目标数组，并将源数组的内容复制到目标数组中。函数的内存拷贝功能。注意，在Java中，这种方法只适用于数组的拷贝，无法直接用于对象的拷贝。在上面的示例中，我们首先定义了一个包含源数据的源数组。的位置0开始，复制的元素个数为源数组的长度。方法将源数组的内容复制到目标数组中。
java深入理解浅拷贝和深拷贝
12-21
在Java编程中，深入理解浅拷贝和深拷贝是非常重要的概念，特别是在处理对象复制时。浅拷贝和深拷贝的区别在于复制对象时对内存中数据的处理方式。 浅拷贝（Shallow Copy）指的是创建一个新的对象，该对象与原对象...
Java中的拷贝（简述c++深浅拷贝）
weixin_45746505的博客
04-28 2435
深拷贝、浅拷贝、Java拷贝
Java基础---传递&拷贝
汤键的博客
07-12 786
Java基础---传递&拷贝
BeanUtils实现对象拷贝和属性复制的使用
悦分享
10-23 2303
BeanUtils实现对象拷贝和属性复制的使用 对于某一属性，即原始对象和目的对象的属性名称相同，就可以拷贝原始对象的属性值到目的对象中。 注意属性必须添加set，get方法，否则拷贝不成功 基本类型之间如果是属性的类型不同，BeanUtils会尝试去强制类型转换，然后去拷贝，如果能转换则不抛出异常。所以在转换时要确保属性名称相同，属性类型最好也相同。 引入不同的包，jar中方法也...
java 编码实现内存拷贝_Java深拷贝和浅拷贝和直接传递的区别
weixin_34409895的博客
02-25 205
一. 前置理解：1.首先你需要了解基本数据类型和引用数据类型，值传递和引用传递，这里就不展开赘述了，不了解的可以自行递归。2.以下面公共代码为例的结构图是这样的image.png敲黑板！！！！ 一定要学好基础知识，否则当你打开一篇文字你会接着打开更多的文章！！！二. 如何实现拷贝首先要实现Cloneable接口，并重写clone()方法，提升可见性，从Object类的clone()方法的访问修饰符...
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
在Java编程语言中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种不同的对象复制方式，它们涉及到内存中数据的复制和引用的处理。理解这两种拷贝方式对于开发过程中正确管理和操作对象至关重要。 浅拷贝，又...
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅拷贝的两种实现方法。 一、浅拷贝 浅拷贝...
Python中的深拷贝和浅拷贝详解
12-25
变量-引用-对象(可变对象，不可变对象)-切片-拷贝(浅拷贝，深拷贝) 【变量-对象-引用】 在Python中一切都是对象，比如说:3, 3.14, ‘Hello’, [1,2,3,4],{‘a’:1}…… 甚至连type其本身都是对象，type对象 Python...
java 编码实现内存拷贝_大文件拷贝，试试NIO的内存映射
weixin_39793189的博客
02-25 284
最近项目里有个需求需要实现文件拷贝，在java中文件拷贝流的读写，很容易就想到IO中的InputStream和OutputStream之类的，但是上网查了一下文件拷贝也是有很多种方法的，除了IO，还有NIO、Apache提供的工具类、JDK自带的文件拷贝方法IO拷贝public class IOFileCopy {private static final int BUFFER_SIZE = 102...
超详细！Java浅拷贝与深拷贝
2302_81982408的博客
05-25 1025
超详细！浅克隆与深克隆的实现与运用
JAVA 浅拷贝和深拷贝
skystep的博客
08-07 3758
在 java 中，默认的拷贝指的是类重写 Object 类中的 clone 方法，调用该方法进行拷贝。使用 clone 方法生生成新的对象，此时在堆中产生新的对象，clone 存放了该对象的引用。对浅拷贝进行加强，对象中引用属性进行 clone 操作，以下例子 User 类 clone 的时候也对 animal 进行拷贝。深拷贝相对于浅拷贝而言，会对所有数据类型都进行拷贝一份，包括这个对象所包含的内部对象。User 类实现 Serializable 接口，对堆区中的实例进行读写，从而实现对实例的全部拷贝。.
java内存分配（堆，栈，方法区，常量池）图解
m0_57816620的博客
10-15 6742
初学内存空间的分配，不足的地方还请大佬们多担待与指点
Java中的深拷贝与浅拷贝
qq_43460095的博客
07-13 6432
浅拷贝：对基本类型数据进行值传递，对引用类型数据进行引用传递的拷贝深拷贝：对基本类型数据进行值传递，对引用类型数据创建一个新的对象，并复制其内容在Java中，所有的对象都继承自，在类中提供了一个方法来供我们对Java对象进行拷贝： 这个方法是的，所以不需要我们来实现。不过需要注意的是，这个方法还是的，这意味着方法只在包或其子类可见。方法还抛出了一个异常，通过源码注释可以知道，当调用了方法的对象类没有实现接口，或者无法克隆对象的时候，会抛出该异常，也就是说，如果要成功的调用接口，首先该类要实现接口。 Clon
java中的三种拷贝方法
最新发布
m0_51663233的博客
06-07 1888
引用拷贝：只复制引用，原对象和新对象指向同一个对象。浅拷贝：创建新对象，但不递归复制成员对象，成员对象仍然是共享的引用。深拷贝：创建新对象，并递归复制所有成员对象，完全独立。这些拷贝方式在实际应用中有不同的使用场景和适用性，根据需要选择合适的拷贝方式可以有效管理内存和对象关系。
Java中的零拷贝
qq_45794943的博客
05-11 6522
前言： 在Java程序中，零拷贝技术分为两种：mmap（内存映射）和sendFile，首先要了解零拷贝的概念：所谓的零拷贝不是不拷贝，而是不经过CPU拷贝，它还是需要拷贝的（比如将数据从硬盘拷贝到内核态），这个零拷贝是从操作系统（CPU）的角度看的 传统的IO拷贝 首先将硬盘上的数据拷贝到内核，然后在经过CPU拷贝将数据从内核拷贝到应用程序内存（用户态），在应用程序内存，用户可以对数据进行操作修改等，然后在经过CPU拷贝将数据从用户缓冲区拷贝到socket缓冲区，然后在经过DMA拷贝，将数据从socket
java关于深拷贝和浅拷贝的理解
qq_42077317的博客
06-07 745
对于基本数据类型就是直接进行值传递，在内存的另一个空间内存放，修改这个值不会影响到拷贝源的值，对于引用数据类型就是进行的是地址传递，并没有对该对象重新开辟一个内存空间进行存放，所以对于引用数据类型的浅拷贝就相当于两个引用指向了同一个内存地址。说明浅拷贝不会拷贝引用类型指向的对象，只会拷贝引用，指向的仍是同一个地址，所以这两个对象的引用对象是同一个对象，修改就会发生改变，浅拷贝也就是一个封装性的赋值操作。3.如果对象引用任何时候都不会被改变，那么没必要使用深拷贝，只需要使用浅拷贝就行了。
Java堆栈内存、堆外内存、零拷贝浅析与代码实现
JiangNanMax的博客
05-11 489
微信公众号：Java随笔录 关注可了解更多Java相关的技术分享。问题或建议，欢迎公众号留言！ 目录Java堆栈内存和堆外内存1. 堆栈内存2. 堆外内存零拷贝公众号 零拷贝，这是个耳熟能详的名词，是开发岗面试中经常提及的问题。最近在回顾Netty的基础原理，还是把NIO中关于堆外内存的知识点过了一遍，这里就针对堆栈内存、堆外内存和零拷贝这几个概念以及相关知识做一下记录。 Java堆栈内存和堆外内存 1. 堆栈内存 堆栈内存，顾名思义，指的是堆内存以及栈内存，其中，堆内存是由Java GC进行管理的内.
java中 深拷贝和浅拷贝
07-22
在Java中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是用于复制对象的两种不同方式。 浅拷贝是指创建一个新对象，然后将原始对象的非静态字段的值复制到新对象中。如果字段是基本数据类型，则复制其值；如果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值