Java深拷贝和浅拷贝区别

Knight_AL

已于 2023-10-26 10:47:32 修改

阅读量675

点赞数 2

分类专栏： java 文章标签： java jvm 开发语言

于 2023-03-01 13:40:59 首次发布

本文链接：https://blog.csdn.net/qq_46548855/article/details/129279178

版权

java 专栏收录该内容

71 篇文章 2 订阅

订阅专栏

本文介绍了Java中的两种拷贝形式：引用拷贝和对象拷贝，重点讲解了浅拷贝和深拷贝的概念，并通过代码示例展示了它们的区别。浅拷贝只复制对象本身，而不复制引用的对象，而深拷贝则会创建一个完全独立的对象副本，包括其引用的对象。此外，文章还提及了值传递和引用传递在拷贝过程中的影响。

摘要由CSDN通过智能技术生成

一、拷贝的两种形式

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)。这就叫做引用拷贝。在这里插入图片描述

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

在这里插入图片描述
深拷贝和浅拷贝都是对象拷贝
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引用指向的是同一个对象，所以说明是浅拷贝。
在这里插入图片描述

三、深拷贝

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对象,所以说是深拷贝。
在这里插入图片描述

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

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

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