【Java深入】深拷贝与浅拷贝详解

最新推荐文章于 2024-04-01 00:11:03 发布
最新推荐文章于 2024-04-01 00:11:03 发布
阅读量2.7w 收藏 365
点赞数 168
分类专栏： Java SE 文章标签： java 深拷贝浅拷贝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baiye_xing/article/details/71788741
版权

1.拷贝的引入

（1）引用拷贝

创建一个指向对象的引用变量的拷贝。

例1：

Teacher teacher = new Teacher("Taylor",26);
Teacher otherteacher = teacher;
System.out.println(teacher);
System.out.println(otherteacher);

输出结果：

blog.Teacher@355da254
blog.Teacher@355da254

结果分析：由输出结果可以看出，它们的地址值是相同的，那么它们肯定是同一个对象。teacher和otherteacher的只是引用而已，他们都指向了一个相同的对象Teacher(“Taylor”,26)。 这就叫做引用拷贝。

例1 图解：
这里写图片描述

（2）对象拷贝

创建对象本身的一个副本。

例2：

Teacher teacher = new Teacher("Swift",26);
Teacher otherteacher = (Teacher)teacher.clone();
System.out.println(teacher);
System.out.println(otherteacher);

输出结果:

blog.Teacher@355da254
blog.Teacher@4dc63996

结果分析：由输出结果可以看出，它们的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量,这就叫做对象拷贝。

例2 图解：
这里写图片描述

注：深拷贝和浅拷贝都是对象拷贝

2.浅拷贝

（1）定义：

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。"里面的对象“会在原来的对象和它的副本之间共享。

简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象

（2）浅拷贝实例：

例3：

public class ShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("Delacey");
        teacher.setAge(29);

        Student2 student1 = new Student2();
        student1.setName("Dream");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student2 student2 = (Student2) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
        System.out.println("修改老师的信息后-------------");

        // 修改老师的信息
        teacher.setName("Jam");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }

}

class Teacher implements Cloneable {
    private String name;
    private int age;

    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;
    }
}

class Student2 implements Cloneable{
    private String name;
    private int age;
    private Teacher teacher;

    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 Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        Object object = super.clone();
        return object;
    }

}

输出结果：

拷贝后
Dream
18
Delacey
29
修改老师的信息后-------------
Jam
Jam

结果分析： 两个引用student1和student2指向不同的两个对象，但是两个引用student1和student2中的两个teacher引用指向的是同一个对象，所以说明是浅拷贝。

例3 图解：
这里写图片描述

3.深拷贝

（1）定义：

深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

（2）实现深拷贝（实例1）：

例4：

public class DeepCopy {
    public static void main(String[] args) throws Exception {
        Teacher2 teacher = new Teacher2();
        teacher.setName("Delacey");
        teacher.setAge(29);

        Student3 student1 = new Student3();
        student1.setName("Dream");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student3 student2 = (Student3) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
        System.out.println("修改老师的信息后-------------");

        // 修改老师的信息
        teacher.setName("Jam");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }
}

class Teacher2 implements Cloneable {
    private String name;
    private int age;

    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;
    }

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

}

class Student3 implements Cloneable {
    private String name;
    private int age;
    private Teacher2 teacher;

    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 Teacher2 getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher2 teacher) {
        this.teacher = teacher;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        // 浅复制时：
        // Object object = super.clone();
        // return object;

        // 改为深复制：
        Student3 student = (Student3) super.clone();
        // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
        student.setTeacher((Teacher2) student.getTeacher().clone());
        return student;
    }

}

输出结果：

拷贝后
Dream
18
Delacey
29
修改老师的信息后-------------
Jam
Delacey

结果分析：
两个引用student1和student2指向不同的两个对象，两个引用student1和student2中的两个teacher引用指向的是两个对象，但对teacher对象的修改只能影响student1对象,所以说是深拷贝。

例4 图解1（teacher姓名Delacey更改前）：

这里写图片描述

例4 图解2（teacher姓名Jam更改后）：

这里写图片描述

（3）利用序列化实现深拷贝（实例2）

例5：

public class DeepCopyServiable {
    public static void main(String[] args) throws Exception {
        Teacher3 t = new Teacher3();
        t.setName("Taylor");
        t.setAge(28);

        Student3 s1 = new Student3();
        s1.setAge(20);
        s1.setName("blank space");
        s1.setTeacher(t);

        Student3 s2 = (Student3) s1.deepClone();

        System.out.println("拷贝后:");
        System.out.println(s2.getName());
        System.out.println(s2.getAge());
        System.out.println(s2.getTeacher().getName());
        System.out.println(s2.getTeacher().getAge());
        System.out.println("---------------------------");

        t.setName("swift");

        System.out.println("修改后：");
        System.out.println(s1.getTeacher().getName());
        System.out.println(s2.getTeacher().getName());
    }
}

class Teacher3 implements Serializable {
    private String name;
    private int age;

    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;
    }

}

class Student3 implements Serializable {
    private String name;
    private int age;
    private Teacher3 teacher;

    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 Teacher3 getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher3 teacher) {
        this.teacher = teacher;
    }

    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();
    }
}

输出结果：

拷贝后:
blank space
20
Taylor
28
---------------------------
修改后：
swift
Taylor

结果分析：说明用序列化的方式实现了对象的深拷贝

白夜行515
关注
专栏目录
Java中的深拷贝和浅拷贝
liuergo的博客
10-20 941
在之前做项目的时候，同组的人因为深拷贝和浅拷贝的问题产生过BUG，当时不是自己负责的部分，没对这个问题做过深入的了解，今天深入学习一下???? 在介绍深拷贝和浅拷贝之前，先温习几个概念。 数据类型 Java中的数据类型有两种： 基本类型：粒度最小的数据类型。主要包括 4种整数类型：int、short、long、byte 2种浮点数类型：float、double 1种字符类型：char 1种布尔...
深拷贝|浅拷贝
最新发布
伏颜的博客
09-18 2287
深拷贝-浅拷贝
Java中的深拷贝(深复制)和浅拷贝(浅复制)
weixin_34249678的博客
12-14 382
深拷贝(深复制)和浅拷贝(浅复制)是两个比较通用的概念，尤其在C++语言中，若不弄懂，则会在delete的时候出问题，但是我们在这幸好用的是Java。虽然java自动管理对象的回收，但对于深拷贝(深复制)和浅拷贝(浅复制)，我们还是要给予足够的重视，因为有时这两个概念往往会给我们带来不小的困惑。 浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。深拷...
Java深拷贝，浅拷贝
tianhongfan10106的专栏
03-07 1021
java
深拷贝和浅拷贝(Java)
m0_67683346的博客
10-15 1482
java中的深拷贝和浅拷贝问题
java 深拷贝与浅拷贝机制详解
08-31
了解和掌握深拷贝与浅拷贝的概念以及如何在Java中实现它们，对于编写高效、健壮的代码至关重要，尤其是在处理复杂的对象结构和数据时。正确地使用拷贝机制可以帮助我们避免不必要的副作用，并确保程序的正确性。
详解java中的深拷贝和浅拷贝（clone()方法的重写、使用序列化实现真正的深拷贝）
08-26
在Java编程中，深拷贝和浅拷贝是两种复制对象的方法，它们涉及到对象的内存管理以及对象引用的处理。本文将深入探讨这两种拷贝方式，并着重讲解如何通过重写`clone()`方法以及使用序列化来实现深拷贝。 1. 浅拷贝：...
Java深拷贝与浅拷贝详解：实例解析与概念探讨
"本文详细探讨了Java中的深拷贝和浅拷贝，通过实例代码展示了两者的区别，并提供了测试示例来帮助理解。" 在Java编程中，深拷贝和浅拷贝是处理对象复制时两个重要的概念，它们主要涉及到对象的复制方式以及对内存中...
Python中的深拷贝和浅拷贝详解
12-25
变量-引用-对象(可变对象，不可变对象)-切片-拷贝(浅拷贝，深拷贝) 【变量-对象-引用】 在Python中一切都是对象，比如说:3, 3.14, ‘Hello’, [1,2,3,4],{‘a’:1}…… 甚至连type其本身都是对象，type对象 Python...
javascript深拷贝和浅拷贝详解
12-09
一、数组的深浅拷贝 在使用JavaScript对数组进行操作的时候，我们经常需要将数组进行备份，事实证明如果只是简单的将它赋予其他变量，那么我们只要更改其中的任何一个，然后其他的也会跟着改变，这就导致了问题的...
java的深拷贝和浅拷贝
weixin_45771158的博客
07-11 4129
浅拷贝和深拷贝
java深拷贝和浅拷贝
不变的24号
04-25 990
1.浅拷贝：对象中某一个引用类型的赋值，引用对象的值回随着修改而修改 2.深拷贝：引用对象重新开启新的空间，不会随着改变而改变；可以通过实现Cloneable接口。
java 深拷贝与浅拷贝
奚学长的工地
10-09 302
1.浅拷贝 第一种可以用 import org.apache.commons.beanutils.PropertyUtils;  这个工具类 PoolFttbVO dest=new PoolFttbVO(); //第一个参数为拷贝结果，第二个参数为 源拷贝对象 PropertyUtils.copyProperties(dest,orig); 第二种，对象实现Cloneable接口，并
Java深拷贝与浅拷贝
weixin_43763430的博客
04-01 1888
但是如果对象中的数据需要经过复杂的计算才能得到，（比如排序、计算哈希值），或者需要从PC网络，数据库，文件系统等非常慢速的io中读取，这种情况下就可以使用原型模式从其他已有对象中直接拷贝得到，而不用每次在创建新对象的时候都重复执行这些耗时的操作。如果对象的创建成本比较大，而同一个类的不同对象之间差别不大（大部分字段都相同，在这种情况下可以利用对已有对象（原型）进行复制（拷贝）的方式来创建新对象，以达到节省创建时间的目的，这种基于原型来创建对象的方式就叫做原形设计模式，简称原形模式。
深拷贝与浅拷贝
第三只眼的专栏
12-07 967
深拷贝与浅拷贝探析1.         深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人名叫张三，后来用他克隆（假设法律允许）了另外一个人，叫李四，不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人。比较典型的就是Value（值）对象，如预定义类型Int32，Double，以及结构（struct），枚举（Enum）等。考虑以下写法
Java深拷贝和浅拷贝
johnhuster的专栏
02-27 259
定义 浅拷贝 基本数据类型 拷贝数值 引用类型 拷贝对象引用 深拷贝 基本数据类型 拷贝数值 引用类型 拷贝引用所对应对象的所有数值 浅拷贝实现方式 1. 拷贝构造方法 拷贝构造方法指的是该类的构造方法参数为该类的对象。使用拷贝构造方法可以很好地完成浅拷贝，直接通过一个现有的对象创建出与该对象属性相同的新的对象。 实现如下（PS：已略去部分代码）： 浅拷贝-拷贝构造 ...
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值