深拷贝＆浅拷贝 & 它们的实现

最新推荐文章于 2022-09-23 22:22:38 发布
最新推荐文章于 2022-09-23 22:22:38 发布
阅读量220 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44613591/article/details/109140152
版权

深拷贝＆浅拷贝

浅拷贝
  • 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。
  • 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。实际上两个对象的该成员变量都指向同一个实例。

在这里插入图片描述

深拷贝
  • 对于深拷贝来说，不仅要复制对象的所有基本数据类型的成员变量值，还要为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象图进行拷贝。

在这里插入图片描述

实现

浅拷贝
  • 通过拷贝构造方法实现浅拷贝：通过修改构造方法来进行拷贝
    class Person{
        //两个属性值：分别代表值传递和引用传递
        private Age age;
        private String name;
        public Person(Age age,String name) {
            this.age=age;
            this.name=name;
        }
        //拷贝构造方法
        public Person(Person p) {
            this.name=p.name;
            this.age=p.age;
        }
        public void setName(String name) {
            this.name=name;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

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

        @Override
        public String toString() {
            return "Age{" +
                    "age=" + age +
                    '}';
        }
    }

    public static void main(String[] args) {
        Copy copy = new Copy();
        Age age = copy.new Age(20);
        Person p1=copy.new Person(age,"AAAAA"); //源数据
        Person p2=copy.new Person(p1); //拷贝数据
        System.out.println("p1 = "+p1);
        System.out.println("p2 = "+p2);
        //修改p1的各属性值，观察p2的各属性值是否跟随变化
        p1.setName("BBBBB");
        age.setAge(99);
        System.out.println("修改后的p1 = "+p1);
        System.out.println("修改后的p2 = "+p2);
    }
/**
输出：
p1 = Person{age=Age{age=20}, name='AAAAA'}
p2 = Person{age=Age{age=20}, name='AAAAA'}
修改后的p1 = Person{age=Age{age=99}, name='BBBBB'}
修改后的p2 = Person{age=Age{age=99}, name='AAAAA'}
*/
  • 通过重写clone()方法进行浅拷贝：Object类是类结构的根类，其中有一个方法为protected Object clone() throws CloneNotSupportedException，这个方法就是进行的浅拷贝。
    • Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。
    • 使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。
    /**
     * 创建年龄类
     */
    class Age implements Cloneable{
        //年龄类的成员变量（属性）
        private int age;
        //构造方法
        public Age(int age) {
            this.age=age;
        }

        public int getAge() {
            return age;
        }

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

        @Override
        public String toString() {
            return this.age+"";
        }
    }
    /**
     * 创建学生类
     */
    class Student implements Cloneable {
        //学生类的成员变量（属性）,其中一个属性为类的对象
        private String name;
        private Age aage;
        private int length;

        //构造方法,其中一个参数为另一个类的对象
        public Student(String name, Age a, int length) {
            this.name = name;
            this.aage = a;
            this.length = length;
        }

        public String getName() {
            return name;
        }

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

        public Age getaAge() {
            return this.aage;
        }

        public void setaAge(Age age) {
            this.aage = age;
        }

        public int getLength() {
            return this.length;
        }

        public void setLength(int length) {
            this.length = length;
        }

        //设置输出的字符串形式
        @Override
        public String toString() {
            return "姓名是： " + this.getName() + "， 年龄为： " + this.getaAge().toString() + ", 长度是： " + this.getLength();
        }

        //重写Object类的clone方法
        @Override
        public Object clone() {
            Object obj = null;
            //调用Object类的clone方法，返回一个Object实例
            try {
                obj = super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return obj;
        }
    }

    public static void main(String[] args) {
        CopyDemo02 copyDemo02 = new CopyDemo02();
        Age a = copyDemo02.new Age(20);
        Student stu1 = copyDemo02.new Student("AAAAA",a,123);

        //通过调用重写后的clone方法进行浅拷贝
        Student stu2=(Student)stu1.clone();
        System.out.println("stu1 = " + stu1.toString());
        System.out.println("stu2 = " + stu2.toString());

        //尝试修改stu1中的各属性，观察stu2的属性有没有变化
        stu1.setName("BBBBB");
        //改变age这个引用类型的成员变量的值
        a.setAge(99);
        //stu1.setaAge(new Age(99));    使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
        stu1.setLength(321);
        System.out.println("修改后： stu1 = " + stu1.toString());
        System.out.println("修改后： stu2 = " + stu2.toString());
    }
/**
stu1 = 姓名是： AAAAA， 年龄为： 200, 长度是： 123
stu2 = 姓名是： AAAAA， 年龄为： 200, 长度是： 123
修改后： stu1 = 姓名是： BBBBB， 年龄为： 100, 长度是： 321
修改后： stu2 = 姓名是： AAAAA， 年龄为： 100, 长度是： 123
*/
深拷贝
  • 通过重写clone方法来实现深拷贝：与通过重写clone方法实现浅拷贝的基本思路一样，只需要为对象图的每一层的每一个对象都实现Cloneable接口并重写clone方法，最后在最顶层的类的重写的clone方法中调用所有的clone方法即可实现深拷贝。简单的说就是：每一层的每个对象都进行浅拷贝=深拷贝。
    /**
     * 创建年龄类
     */
    class Age implements Cloneable{
        //年龄类的成员变量（属性）
        private int age;
        //构造方法
        public Age(int age) {
            this.age=age;
        }

        public int getAge() {
            return age;
        }

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

        @Override
        public Object clone() {
            Object obj=null;
            try {
                obj=super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return obj;
        }

        @Override
        public String toString() {
            return this.age+"";
        }
    }
    /**
     * 创建学生类
     */
    class Student implements Cloneable {
        //学生类的成员变量（属性）,其中一个属性为类的对象
        private String name;
        private Age aage;
        private int length;

        //构造方法,其中一个参数为另一个类的对象
        public Student(String name, Age a, int length) {
            this.name = name;
            this.aage = a;
            this.length = length;
        }

        //eclipe中alt+shift+s自动添加所有的set和get方法
        public String getName() {
            return name;
        }

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

        public Age getaAge() {
            return this.aage;
        }

        public void setaAge(Age age) {
            this.aage = age;
        }

        public int getLength() {
            return this.length;
        }

        public void setLength(int length) {
            this.length = length;
        }

        //设置输出的字符串形式
        @Override
        public String toString() {
            return "姓名是： " + this.getName() + "， 年龄为： " + this.getaAge().toString() + ", 长度是： " + this.getLength();
        }

        //重写Object类的clone方法
        @Override
        public Object clone() {
            Object obj=null;
            //调用Object类的clone方法——浅拷贝
            try {
                obj= super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            //调用Age类的clone方法进行深拷贝
            //先将obj转化为学生类实例
            Student stu=(Student)obj;
            //学生类实例的Age对象属性，调用其clone方法进行拷贝
            stu.aage=(Age)stu.getaAge().clone();
            return obj;
        }
    }

    /* 层次调用clone方法实现深拷贝 */
    public static void main(String[] args) {
        CopyDemo03 copyDemo03 = new CopyDemo03();
        Age a = copyDemo03.new Age(100);
        Student stu1 = copyDemo03.new Student("AAAAA",a,100);

        //通过调用重写后的clone方法进行浅拷贝
        Student stu2=(Student)stu1.clone();
        System.out.println("stu1 = " + stu1.toString());
        System.out.println("stu2 = " + stu2.toString());

        //尝试修改stu1中的各属性，观察stu2的属性有没有变化
        stu1.setName("BBBBB");
        //改变age这个引用类型的成员变量的值
        a.setAge(200);
        //stu1.setaAge(new Age(99));    使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
        stu1.setLength(200);
        System.out.println("stu1 = " + stu1.toString());
        System.out.println("stu2 = " + stu2.toString());
    }
/**
stu1 = 姓名是： AAAAA， 年龄为： 100, 长度是： 100
stu2 = 姓名是： AAAAA， 年龄为： 100, 长度是： 100
stu1 = 姓名是： BBBBB， 年龄为： 200, 长度是： 200
stu2 = 姓名是： AAAAA， 年龄为： 100, 长度是： 100
*/
  • 通过对象序列化实现深拷贝：虽然层次调用clone方法可以实现深拷贝，但是显然代码量实在太大。特别对于属性数量比较多、层次比较深的类而言，每个类都要重写clone方法太过繁琐。将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。
    /**
     * 创建年龄类
     */
    class Age implements Serializable {
        //年龄类的成员变量（属性）
        private int age;
        //构造方法
        public Age(int age) {
            this.age=age;
        }

        public int getAge() {
            return age;
        }

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

        @Override
        public String toString() {
            return this.age+"";
        }
    }
    /**
     * 创建学生类
     */
    class Student implements Serializable{
        //学生类的成员变量（属性）,其中一个属性为类的对象
        private String name;
        private Age aage;
        private int length;
        //构造方法,其中一个参数为另一个类的对象
        public Student(String name,Age a,int length) {
            this.name=name;
            this.aage=a;
            this.length=length;
        }
        //eclipe中alt+shift+s自动添加所有的set和get方法
        public String getName() {
            return name;
        }

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

        public Age getaAge() {
            return this.aage;
        }

        public void setaAge(Age age) {
            this.aage=age;
        }

        public int getLength() {
            return this.length;
        }

        public void setLength(int length) {
            this.length=length;
        }
        //设置输出的字符串形式
        @Override
        public String toString() {
            return "姓名是： "+this.getName()+"， 年龄为： "+this.getaAge().toString()+", 长度是： "+this.getLength();
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException  {
        CopyDemo04 copyDemo04 = new CopyDemo04();
        Age a = copyDemo04.new Age(100);
        Student stu1 = copyDemo04.new Student("AAAAA",a,100);
        //通过序列化方法实现深拷贝
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(bos);
        oos.writeObject(stu1);
        oos.flush();
        ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        Student stu2=(Student)ois.readObject();
        System.out.println("stu1 = " + stu1.toString());
        System.out.println("stu2 = " + stu2.toString());
        //尝试修改stu1中的各属性，观察stu2的属性有没有变化
        stu1.setName("BBBBB");
        //改变age这个引用类型的成员变量的值
        a.setAge(200);
        stu1.setLength(200);
        System.out.println("stu1 = " + stu1.toString());
        System.out.println("stu2 = " + stu2.toString());
    }
/**
stu1 = 姓名是： AAAAA， 年龄为： 100, 长度是： 100
stu2 = 姓名是： AAAAA， 年龄为： 100, 长度是： 100
stu1 = 姓名是： BBBBB， 年龄为： 200, 长度是： 200
stu2 = 姓名是： AAAAA， 年龄为： 100, 长度是： 100
*/

总结

  • 浅拷贝和深拷贝的概念

  • 2 种浅拷贝方法 和 2种深拷贝方法

  • 其实我们要创建对象有五种方法

在这里插入图片描述

碌碌无为_心不在烟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
Qt 对象深拷贝和浅拷贝举例
m0_45463480的博客
08-30 750
上述代码中，p1和p2是相同类型的Person对象，当进行浅拷贝时，p2的name和age成员变量会直接复制自p1。这意味着p1和p2都指向相同的实际数据，如果更改其中一个对象的数据，另一个对象的数据也会相应地更改。需要注意的是，对于Qt的某些类，它们已经实现了拷贝构造函数和赋值运算符重载，以正确处理深拷贝。但是对于自定义的类或处理裸指针等情况，则需要手动实现深拷贝的逻辑，以确保数据的独立性。深拷贝是指创建一个新的对象，并将原始对象的成员变量的值复制到新对象中。两个对象拥有自己独立的数据副本，互不影响。
浅拷贝和深拷贝
最新发布
温暖前端的博客
02-27 1102
复制方式：浅拷贝只复制对象或数组的第一层属性或元素，而深拷贝会递归复制所有属性或元素，包括嵌套的对象或数组。引用关系：浅拷贝复制的对象或数组中的引用类型属性仍然会指向同一个引用，而深拷贝会创建新的引用，使得新对象或数组与原始数据结构完全独立。性能开销：由于深拷贝需要递归复制所有属性或元素，所以性能开销比浅拷贝更大。在处理大型对象或数组时，深拷贝可能会导致性能问题。应用场景：浅拷贝通常用于复制简单的对象或数组，而深拷贝适用于复制复杂的对象或数组，特别是包含嵌套的对象或数组。
浅拷贝，深拷贝，隐式共享的三个例子
z278930050的专栏
12-19 1359
1.浅拷贝：    浅拷贝就比如像引用类型    浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。举个例子，一个人一开始叫张三，后来改名叫李四了，可是还是同一个人，不管是张三缺胳膊少腿还是李四缺胳膊少腿，都是这个人倒霉。 2.深拷贝：    而深拷贝就比如值类型。   深拷贝是指源对象与拷贝对象互
QPixmap的深拷贝和浅拷贝
05-28 5512
在最近的项目中用到了QPixmap，涉及多线程操作QPixmap对象，为了简单，比如在线程1中构造了一个QPixmap对象，传入线程2，这时调用的函数为operator=(const QPixmap & pixmap)，对于不了解QPixmap类的这个函数，误以为会进行深拷贝，导致后面的程序出错问题！该函数利用了浅拷贝，保存了有效数据的地址！如果要进行深拷贝，则需要调用QPixmap的另外一个成员
C++中的深拷贝和浅拷贝 QT中的深拷贝，浅拷贝和隐式共享
dingzhenzha7040的博客
02-22 616
下面是C++中定义的深，浅拷贝 当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数： （1）一个对象以值传递的方式传入函数体 （2）一个对象以值传递的方式从函数返回 （3）一个对象需要通过另外一个对象进行初始化。 如果在类中没有显...
深拷贝和浅拷贝
miniBeier的博客
06-11 253
深拷贝和浅拷贝是只针对Object和Array这样的引用数据类型的，都是只拷贝对象自身的属性，不对原型属性进行拷贝。 深拷贝和浅拷贝的拷贝层级问题 1）浅拷贝是拷贝一层，深层的数据复制的是内存地址 2）深拷贝是每一层的数据都会拷贝出来，两个对象是完全独立的 赋值和浅拷贝的区别 1）赋值：两个变量保存的是同一个对象的内存地址，指向同一个存储空间，无论通过哪个变量对对象进行改变，通过另一个变量查找到的对象也是改变的 2）浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性
java深入理解浅拷贝和深拷贝
12-21
在Java编程中，深入理解浅拷贝和深拷贝是非常重要的概念，特别是在处理对象复制时。浅拷贝和深拷贝的区别在于复制对象时对内存中数据的处理方式。 浅拷贝（Shallow Copy）指的是创建一个新的对象，该对象与原对象...
Python 深拷贝和浅拷贝详解
03-09
在Python编程语言中，深拷贝和浅拷贝是两种不同的复制对象的方法，它们涉及到对象内存的管理和数据结构的复制。这两个概念对于理解和处理复杂的对象结构至关重要。 **浅拷贝**： 浅拷贝（Shallow Copy）是创建一个...
python的深拷贝与浅拷贝
12-21
Python中的深拷贝和浅拷贝是编程时处理对象复制的关键概念，特别是在处理复杂数据结构时。它们决定了拷贝操作的“深度”，即创建新对象的程度。本文将深入探讨这两种拷贝的区别，以及如何在Python中正确使用它们。 ...
JS浅拷贝和深拷贝原理与实现方法分析
12-11
JavaScript中的浅拷贝和深拷贝是两种不同的对象复制方式，它们在处理复杂对象时有着显著的区别。在JavaScript中，对象是引用类型，因此当一个对象被复制时，如果不进行特殊处理，复制的只是指向原对象的引用，而非...
前端深拷贝浅拷贝的问题
01-20
在前端开发中，深拷贝和浅拷贝是两个重要的概念，它们关乎到对象和数组复制的机制。当需要创建一个原始对象或数组的副本，而不希望改变原始数据时，就需要考虑这两种拷贝方式。 首先，浅拷贝是创建一个新对象，这个...
Qt 隐式共享之深拷贝、浅拷贝
一个老菜鸟的学习分享
04-03 3695
深拷贝、浅拷贝，隐式共享
Qt学习：深拷贝&浅拷贝&隐式共享
imxiangzi的专栏
11-02 2321
综述： 当两个对象要共享一份数据时，如果数据不改变，不进行数据的复制，通过浅拷贝就可以数据的共享；而当对象需要改变数据时，则做深贝。           程序在处理共享对象时，会使用浅拷贝和深拷贝这两种方法复制对象。       (1)深拷贝：即就是生成对象的一个完整的复制品；       (2)浅拷贝：只是一个引用复制(比如仅仅复制指向共享数据的指针)。 这样看来，深拷贝其实是代价比较高
C++拷贝构造函数+深拷贝+浅拷贝
m0_45463480的博客
11-05 186
C++拷贝构造函数 一、浅拷贝 当将一个对象赋值给另外一个对象的时候，只会调用一次构造函数 而此时，会默认再调用一次拷贝构造函数(浅拷贝)。 [空间是同一块，拷贝对象（dest）和被拷贝对象(src)] 不安全，内存可能泄露。 二、深拷贝 自己实现拷贝构造函数，称为深拷贝,拷贝对象自己新申请一块空间，他们之间不会出现段错误。 总结：对象赋值的时候一定会调用默认(浅)拷贝构造函数，所以要自己实现深拷贝，防止内存泄漏 三：拷贝构造函数 创建了拷贝对象，而不定义拷贝函数，构造函数申请空间时， 会出现段错误，（析构
C# 实现对象的深浅拷贝的三种方式代码示例
u010555784的博客
09-23 3976
面试的时候经常被问到c#对象的深浅拷贝实现以及区别，今天我们就来讲一下深拷贝和浅拷贝到底是什么。首先我们讲讲浅拷贝，浅拷贝就是将对象中的所有字段复制到新对象中去，浅拷贝对于值类型和引用类型有不同的影响。值类型的值被复制到副本中后，修改副本中的值不会影响原来对象的值。然而引用类型的属性被复制到副本中后，再修改副本中的值是会导致原来对象的值被修改的。当然上面说到的引用类型不包含string。那么为什么引用类型修改副本里的值会造成原来对象的值变化而string类型就不会呢？首先我们需要知道string类型实际上是
对象克隆以及clone()方法实现时的深拷贝和浅拷贝
JKSon_66的博客
07-16 2846
版权声明：本文为博主原创文章，未经博主允许不得转载.........
ConcurrentModificationException异常原因和解决方法
热门推荐
qq_44613591的博客
02-25 8万+
首先看一下一个例子举出 ConcurrentModificationException 的出现场景： public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(){ { add(1); add(2); add(3); } }; Iterator&
浅谈 CAS 及其缺点和解决方案
qq_44613591的博客
10-14 2114
什么是 CAS 机制？ CAS 英文就是 compare and swap ，也就是比较并交换，首先它是一个原子操作，可以避免被其他线程打断。在Java并发中，我们最初接触的应该就是synchronized关键字了，但是synchronized属于重量级锁，很多时候会引起性能问题，虽然在新的JDK中对其已经进行了优化。volatile也是个不错的选择，但是volatile不能保证原子性，只能在某些场合下使用。那么问题来了，这个 CAS 机制是怎么在不加锁的情况下来保证共享资源的互斥呢？ synchro
Netty对于粘包和拆包问题的解决方案
qq_44613591的博客
03-15 836
前言 什么是粘包拆包？ 拆包和粘包是在socket编程中经常出现的情况，在socket通讯过程中，如果通讯的一端一次性连续发送多条数据包，tcp协议会将多个数据包打包成一个tcp报文发送出去，这就是所谓的粘包。而如果通讯的一端发送的数据包超过一次tcp报文所能传输的最大值时，就会将一个数据包拆成多个最大tcp长度的tcp报文分开传输，这就叫做拆包。 我们看一下下面这张图就知道了： 粘包拆包产生的原因 数据流在TCP协议下传播，因为协议本身对于流有一些规则的限制，这些规则会导致当前对端接收到的数据包不
如何实现深拷贝和浅拷贝
05-12
深拷贝和浅拷贝是针对对象（包括数组）的复制操作，它们的区别在于复制出来的新对象与原对象之间的关系不同。 浅拷贝只复制对象本身，而不会复制对象内部的子对象，新对象和原对象之间共享子对象。例如，对于一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值