深入理解深拷贝和浅拷贝

港控/mmm° 2023-09-28 23:11 10阅读 0赞

##### 一、拷贝 #####

###### 1. 引用拷贝 ######

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

public class QuoteCopy {
        
        public static void main(String[] args) {
        
            Teacher teacher = new Teacher("riemann", 28);
            Teacher otherTeacher = teacher;
            System.out.println(teacher);
            System.out.println(otherTeacher);
        }
    }
    class Teacher {
        
        private String name;
        private int age;
        public Teacher(String name, int age) {
        
            this.name = name;
            this.age = 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;
        }
    }

结果：  
![在这里插入图片描述][ad2ffb05daa64dd18c94669fcdc11cea.png]  
结果分析：由输出结果可以看出，它们的地址值是相同的，那么它们肯定是同一个对象。  
teacher和otherTeacher的只是引用而已，他们都指向了一个相同的对象Teacher(“riemann”,28)。  
这就叫做引用拷贝  
![在这里插入图片描述][a5576e306bfa4ba78cffc9211f44efd7.png]

###### 2. 对象拷贝 ######

创建对象本身的一个副本

public class ObjectCopy {
        
        public static void main(String[] args) throws CloneNotSupportedException {
        
            Teacher teacher = new Teacher("riemann", 28);
            Teacher otherTeacher = (Teacher) teacher.clone();
            System.out.println(teacher);
            System.out.println(otherTeacher);
        }
    }
    class Teacher implements Cloneable {
        
        private String name;
        private int age;
        public Teacher(String name, int age) {
        
            this.name = name;
            this.age = 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;
        }
        public Object clone() throws CloneNotSupportedException {
        
            Object object = super.clone();
            return object;
        }
    }

![在这里插入图片描述][759fb6b7df2d44d38f76692d3cbd9c1a.png]  
结果分析：由输出结果可以看出，它们的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量,这就叫做对象拷贝  
![在这里插入图片描述][6dfb90735a65464982cd1b0283203ef3.png]

##### 二、浅拷贝和深拷贝 #####

深拷贝和浅拷贝都是对象拷贝  
在 Java 中，除了基本数据类型（元类型）之外，还存在 类的实例对象 这个引用数据类型。  
而一般使用 = 号做赋值操作的时候。对于基本数据类型，实际上是拷贝的它的值，但是对于对象而言，其实赋值的只是这个对象的引用，将原对象的引用传递过去，他们实际上还是指向的同一个对象。  
而浅拷贝和深拷贝就是在这个基础之上做的区分，如果在拷贝这个对象的时候，只对基本数据类型进行了拷贝，而对引用数据类型只是进行了引用的传递，而没有真实的创建一个新的对象，则认为是浅拷贝。  
反之，在对引用数据类型进行拷贝的时候，创建了一个新的对象，并且复制其内的成员变量，则认为是深拷贝。  
所以到现在，就应该了解了，所谓的浅拷贝和深拷贝，只是在拷贝对象的时候，对 类的实例对象 这种引用数据类型的不同操作而已。

##### 三、浅拷贝 #####

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

public class ShallowCopy {
        
        public static void main(String[] args) throws CloneNotSupportedException {
        
            Teacher teacher = new Teacher();
            teacher.setName("riemann");
            teacher.setAge(28);
            Student student1 = new Student();
            student1.setName("edgar");
            student1.setAge(18);
            student1.setTeacher(teacher);
            Student student2 = (Student) 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("jack");
            System.out.println("student1的teacher为： " + student1.getTeacher().getName());
            System.out.println("student2的teacher为： " + 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 Student 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;
        }
        public Object clone() throws CloneNotSupportedException {
        
            Object object = super.clone();
            return object;
        }
    }

输出结果：

-------------拷贝后-------------
    edgar
    18
    riemann
    28
    -------------修改老师的信息后-------------
    student1的teacher为： jack
    student2的teacher为： jack

结果分析： 两个引用student1和student2指向不同的两个对象，但是两个引用student1和student2中的两个teacher引用指向的是同一个对象，所以说明是浅拷贝。  
![在这里插入图片描述][0068dc9ef7074284b2fffc184005b790.png]

##### 四、深拷贝 #####

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

public class DeepCopy {
        
        public static void main(String[] args) throws CloneNotSupportedException {
        
            Teacher teacher = new Teacher();
            teacher.setName("riemann");
            teacher.setAge(28);
            Student student1 = new Student();
            student1.setName("edgar");
            student1.setAge(18);
            student1.setTeacher(teacher);
            Student student2 = (Student) 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("jack");
            System.out.println("student1的teacher为： " + student1.getTeacher().getName());
            System.out.println("student2的teacher为： " + 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;
        }
        public Object clone() throws CloneNotSupportedException {
        
            return super.clone();
        }
    }
    class Student 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;
        }
        public Object clone() throws CloneNotSupportedException {
        
            // 浅复制时：
            // Object object = super.clone();
            // return object;
            // 改为深复制：
            Student student = (Student) super.clone();
            // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
            student.setTeacher((Teacher) student.getTeacher().clone());
            return student;
        }
    }

输出结果：

-------------拷贝后-------------
    edgar
    18
    riemann
    28
    -------------修改老师的信息后-------------
    student1的teacher为： jack
    student2的teacher为： riemann

结果分析：两个引用student1和student2指向不同的两个对象，两个引用student1和student2中的两个teacher引用指向的是两个对象，但对teacher对象的修改只能影响student1对象,所以说是深拷贝。  
![在这里插入图片描述][1fc5e4cd79b54183a10f7fdc752e703a.png]

[ad2ffb05daa64dd18c94669fcdc11cea.png]: https://img-blog.csdnimg.cn/ad2ffb05daa64dd18c94669fcdc11cea.png
[a5576e306bfa4ba78cffc9211f44efd7.png]: https://img-blog.csdnimg.cn/a5576e306bfa4ba78cffc9211f44efd7.png
[759fb6b7df2d44d38f76692d3cbd9c1a.png]: https://img-blog.csdnimg.cn/759fb6b7df2d44d38f76692d3cbd9c1a.png
[6dfb90735a65464982cd1b0283203ef3.png]: https://img-blog.csdnimg.cn/6dfb90735a65464982cd1b0283203ef3.png
[0068dc9ef7074284b2fffc184005b790.png]: https://img-blog.csdnimg.cn/0068dc9ef7074284b2fffc184005b790.png
[1fc5e4cd79b54183a10f7fdc752e703a.png]: https://img-blog.csdnimg.cn/1fc5e4cd79b54183a10f7fdc752e703a.png