当前位置：首页 > article >正文

Java中的深拷贝和浅拷贝

article 2025/1/23 7:23:57

🍎引出拷贝

🍎浅拷贝

🍎深拷贝

🍎总结

引出拷贝

现在有一个学生类和书包类，在学生类中有引用类型的书包变量：

class SchoolBag {
    private String brand;   //书包的品牌
    private int size;   //书包的尺寸
    //getter、setter略

    public SchoolBag(String brand, int size) {
        this.brand = brand;
        this.size = size;
    }

    @Override
    public String toString() {
        return "SchoolBag{" +
                "brand='" + brand + '\'' +
                ", size=" + size +
                '}';
    }
}

class Student {
    private String name;
    private int age;
    private SchoolBag schoolBag;

    public Student(String name, int age, SchoolBag schoolBag) {
        this.name = name;
        this.age = age;
        this.schoolBag = schoolBag;
    }

    //getter、setter略

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

创建一个学生对象，现在想在内存中拷贝一份和这个学生对象指向的对象相同的对象，那么应该怎么去做呢？

可能我们会像下边这样写：

...
Student stu1 = new Student("张华",18,new SchoolBag("小米",4));
//直接创建一个新的引用指向这个stu1指向的对象
Student stu2 = stu1;

这显然是错误的，这从内存的分布上就可以知道，stu1与stu2虽然是两个不同的引用变量，但是指向的是堆内存中的同一块空间或者说指向的是同一个对象，并没有真正实现克隆的效果。它们两个引用和引用对象在内存中的关系如图：

那么要怎么实现对象内存的拷贝呢？

浅拷贝

我们可以通过使用Java中的clone方法，该clone方法是Object类中定义的，因此我们只需要在自己的类中重写这个方法，就可以实现对象的拷贝。但是clone方法的使用，并不只是单纯的重写就可以实现效果的，下面我们依次来看：

1.待克隆对象所在类重写clone方法

class Student {
    private String name;
    private int age;
    private SchoolBag schoolBag;

    public Student(String name, int age, SchoolBag schoolBag) {
        this.name = name;
        this.age = age;
        this.schoolBag = schoolBag;
    }

    //getter、setter略

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

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

调用重写的clone方法，克隆对象，会发现，报错了：

哦😂，原来还得让待克隆对象所在类实现Cloneable接口，但是当我们查看这个接口的内容时，却发现这是一个空接口：

为什么是一个空接口呢？

这里可以记作它是一个标记接口，实现Cloneable接口的类被标记为可以被clone的类。

现在我们让Student类实现Cloneable接口再试试看能不能克隆成功。

2.实现Cloneable接口

class Student implements Cloneable{
    private String name;
    private int age;
    private SchoolBag schoolBag;

    public Student(String name, int age, SchoolBag schoolBag) {
        this.name = name;
        this.age = age;
        this.schoolBag = schoolBag;
    }

    //getter、setter略

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

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

现在再次尝试clone，嗯...又报错了......

原来时异常，我们把异常抛给JVM一下：

啊，还报错...

原来是clone方法的返回类型时Object：

我们进行向下转型，然后进行克隆输出会发现克隆成功了：

现在克隆出来的对象以及原型在内存中因该是这样分布的：

当我们修改stu1对象中的schoolbag成员变量后再进行对象的输出，会发现stuClone对象的schoolbag中的值也发生了变化，这是为什么？？？？？

这是因为clone出来的stuClone对象和stu1对象的引用成员变量schoolbag指向的还是同一片内存空间，二者还是共享这一片内存空间。

因此我们可以得到何为浅拷贝？

当引用变量指向的对象中还包含引用变量时，如果只对当前的外部的引用变量进行clone，克隆出来对象的基本数据类型都会被正常拷贝；而内部的引用变量只是将引用的值clone给了另一个clone对象的引用，因此无法在真正意义上实现对象的拷贝，下面我们来解决这种clone后仍存在成员变量有内存共享的问题。

深拷贝

既然clone方法能够实现对对象的拷贝，那么我们在引用变量内部的引用变量身上再使用一次clone方法不就可以解决这种浅拷贝问题了吗？

现在我们进行上述操作，让SchoolBag类重写clone方法并且实现标记接口Cloneable：

class SchoolBag implements Cloneable{
    private String brand;   //书包的品牌
    private int size;   //书包的尺寸
    //getter、setter略

    public SchoolBag(String brand, int size) {
        this.brand = brand;
        this.size = size;
    }

    @Override
    public String toString() {
        return "SchoolBag{" +
                "brand='" + brand + '\'' +
                ", size=" + size +
                '}';
    }

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

在对Student对象进行克隆是也对其中的引用成员变量进行克隆，我们只需要在Student类的clone方法中这样写就可以了：

class Student {
    ...
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student stuClone = (Student)super.clone();
        SchoolBag schoolbagClone = (SchoolBag) this.schoolBag.clone();
        stuClone.setSchoolBag(schoolbagClone);
        return stuClone;
    }
    ...
}

现在我们在进行stu对象的schoolbag修改后的输出，会发现stu1对象的修改已经不会影响stuClone对象了，二者之间已经没有共享的存储空间了：