Java深拷贝和浅拷贝区别

r囧r小猫 2024-03-26 16:01 67阅读 0赞

#### 目录 ####

*  一、拷贝的两种形式
 *   *  1.引用拷贝
     *  2.对象拷贝
 *  二、浅拷贝
 *  三、深拷贝
 *  四、什么是浅拷贝和深拷贝
 *  五、关于值传递和引用传递

## 一、拷贝的两种形式 ##

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

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

public class QuoteCopy {
        
        public static void main(String[] args) {
        
            Teacher teacher = new Teacher("donglin", 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;
        }
    }

输出结果：

com.donglin.ss.Teacher@1540e19d
    com.donglin.ss.Teacher@1540e19d

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

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

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

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

输出结果：

com.donglin.ss.Teacher1@1540e19d
    com.donglin.ss.Teacher1@677327b6

![在这里插入图片描述][73fad0df79f3485d9be89421e578e2db.png]  
**深拷贝和浅拷贝都是对象拷贝**  
Object.clone()方法属于浅拷贝。如果想使用深拷贝，必须在类里面重写clone()方法。

## 二、浅拷贝 ##

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

public class ShallowCopy {
        
        public static void main(String[] args) throws CloneNotSupportedException {
        
            Teacher teacher = new Teacher();
            teacher.setName("donglin");
            teacher.setAge(28);
    
            Student student1 = new Student();
            student1.setName("huya");
            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("lisi");
            System.out.println("student1的teacher为： " + student1.getTeacher().getName());
            System.out.println("student2的teacher为： " + student2.getTeacher().getName());
            student1.setAge(10);
            System.out.println(student1.getAge());
            System.out.println(student2.getAge());
    
    
    
    
        }
    }
    
    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;
        }
    }

输出结果：

-------------拷贝后-------------
    huya
    18
    donglin
    28
    -------------修改老师的信息后-------------
    student1的teacher为： lisi
    student2的teacher为： lisi
    10
    18

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

## 三、深拷贝 ##

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

public class DeepCopy {
        
        public static void main(String[] args) throws CloneNotSupportedException {
        
            Teacher teacher = new Teacher();
            teacher.setName("donglin");
            teacher.setAge(28);
    
            Student student1 = new Student();
            student1.setName("huya");
            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("lisi");
            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;
    
        }
    }

输出结果：

-------------拷贝后-------------
    huya
    18
    donglin
    28
    -------------修改老师的信息后-------------
    student1的teacher为： lisi
    student2的teacher为： donglin

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

## 四、什么是浅拷贝和深拷贝 ##

浅拷贝（shallow copy）：只复制指向某个对象的指针，而不复制对象本身，新旧对象共享一块内存；  
深拷贝（deep copy）：复制并创建一个一摸一样的对象，不共享内存，修改新对象，旧对象保持不变；

*  拷贝浅是创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。
 *  深拷贝是将一个对象从内存中完整的拷贝一份出来，从堆内存中开辟一个新的区域存放新对象，且修改新对象不会影响原对象。

## 五、关于值传递和引用传递 ##

[https://donglin.blog.csdn.net/article/details/126078723][https_donglin.blog.csdn.net_article_details_126078723]

[d2fd7f421aa24589ac7114d4044c14f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/6a1c03b3adba4cd8a3310ac59dd6b6d4.png
[73fad0df79f3485d9be89421e578e2db.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/bca7cdcb8f5a4daea839fa02be508a06.png
[592e23ab15dd492c9c2951a6aaf929a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ecfc472dc99e440f9b144896f35e1eaf.png
[28caa7ffb3a54696b942f0daba186c03.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2479315dd2d640a9947f8e875b086d42.png
[https_donglin.blog.csdn.net_article_details_126078723]: https://donglin.blog.csdn.net/article/details/126078723