Java中的深拷贝和浅拷贝介绍

文章目录

    • 基本类型和引用类型
    • Clone方法
    • 浅拷贝
    • 深拷贝
    • 小结


在讲解什么是深拷贝和浅拷贝之前,我们先来了解一下什么是基本类型和引用类型。

基本类型和引用类型

基本类型也称为值类型,分别是字符类型 char,布尔类型 boolean以及数值类型 byte、short、int、long、float、double。

引用类型则包括类、接口、数组、枚举等。

Java 将内存空间分为堆和栈。基本类型直接在栈中存储数值,而引用类型是将引用放在栈中,实际存储的值是放在堆中,通过栈中的引用指向堆中存放的数据。

Java中的深拷贝和浅拷贝介绍_第1张图片

上图定义的 a 和 b 都是基本类型,其值是直接存放在栈中的;而 c 和 d 是 String 声明的,这是一个引用类型,引用地址是存放在 栈中,然后指向堆的内存空间。

下面 d = c;这条语句表示将 c 的引用赋值给 d,那么 c 和 d 将指向同一块堆内存空间。

Clone方法

本篇博客我们讲解的是 Java 的深拷贝和浅拷贝,其实现方式正是通过调用 Object 类的 clone() 方法来完成。在 Object.class 类中,源码为:

protected native Object clone() throws CloneNotSupportedException; 

这是一个用 native 关键字修饰的方法,只需要知道用 native 修饰的方法就是告诉操作系统,这个方法我不实现了,让操作系统去实现。具体怎么实现我们不需要了解,只需要知道 clone方法的作用就是复制对象,产生一个新的对象。

浅拷贝

浅拷贝是按位拷贝对象,它会创建一个新对象,这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型,拷贝的就是基本类型的值;如果属性是内存地址(引用类型),拷贝的就是内存地址 ,因此如果其中一个对象改变了这个地址,就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝),即只复制对象空间而不复制资源。

实现对象拷贝的类,需要实现 Cloneable 接口,并覆写 clone() 方法。

public class Address {

    private String province;
    private String city;

    public void setAddress(String province, String city) {
        this.province = province;
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address [province=" + province + ", city=" + city + "]";
    }
}
public class Student implements Cloneable {

    private String name;
    private int age;
    private Address address;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.address = new Address();
    }

    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 void setAddress(String province, String city) {
        address.setAddress(province, city);
    }

    public void display(String name) {
        System.out.println(name + ":" + "name=" + name + ", age=" + age + "," + address);
    }

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

这是一个我们要进行赋值的原始类 Student。下面我们产生一个 Student对象,并调用其 clone 方法复制一个新的对象。

注意:调用对象的 clone 方法,必须要让类实现 Cloneable 接口,并且覆写 clone 方法。

测试:

    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student("小明",20);
        s1.setAddress("安徽","合肥");
        Student s2 = (Student) s1.clone();
        System.out.println("S1:"+s1);
        System.out.println("s1.getName:"+s1.getName().hashCode());
        System.out.println("S2:"+s2);
        System.out.println("s2.getName:"+s2.getName().hashCode());

        s1.display("s1");
        s2.display("s2");
        s2.setAddress("安徽","安庆");
        s1.display("s1");
        s2.display("s2");
    }

输出结果:

S1:org.example.jvm.Student@2a84aee7
s1.getName:756703
S2:org.example.jvm.Student@a09ee92
s2.getName:756703
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=合肥]
s1:name=s1, age=20,Address [province=安徽, city=安庆]
s2:name=s2, age=20,Address [province=安徽, city=安庆]

首先我们创建一个Student类的对象 s1,其name 为小明,age为20,地址类 Address 两个属性为 安徽和合肥。接着我们调用 clone() 方法复制另一个对象 s2,接着打印这两个对象的内容。

分析结果:

  • 从第 1 行和第 3 行打印结果来看,这是两个不同的对象。

  • 从第 5 行和第 6 行打印的对象内容看,原对象 s1 和克隆出来的对象 s2 内容完全相同。

  • 我们更改一下克隆对象 s2 的属性 Address 为安徽安庆(原对象 s1 是安徽合肥),但是从第 7 行和第 8 行打印结果来看,原对象 s1 和克隆对象 s2 的 Address 属性都被修改了。

  • 对象 Student 的属性 Address,经过 clone 之后,其实只是复制了其引用,他们指向的还是同一块堆内存空间,当修改其中一个对象的属性 Address,另一个也会跟着变化。

Java中的深拷贝和浅拷贝介绍_第2张图片

浅拷贝:创建一个新对象,然后将当前对象的非静态字段复制到该新对象,如果字段是值类型的,那么对该字段执行复制;如果该字段是引用类型的话,则复制引用但不复制引用的对象。因此,原始对象及其副本引用同一个对象。

深拷贝

深拷贝,在拷贝引用类型成员变量时,为引用类型的数据成员另辟了一个独立的内存空间,实现真正内容上的拷贝。

Java中的深拷贝和浅拷贝介绍_第3张图片

对于 Student 的引用类型的成员变量 Address ,需要实现 Cloneable 并重写 clone() 方法。

public class Address implements Cloneable{

    private String province;
    private String city;

    public void setAddress(String province, String city) {
        this.province = province;
        this.city = city;
    }

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

    @Override
    public String toString() {
        return "Address [province=" + province + ", city=" + city + "]";
    }
}

Studentclone() 方法中,需要拿到拷贝自己后产生的新的对象,然后对新的对象的引用类型再调用拷贝操作,实现对引用类型成员变量的深拷贝。

public class Student implements Cloneable {

    private String name;
    private int age;
    private Address address;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.address = new Address();
    }

    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 void setAddress(String province, String city) {
        address.setAddress(province, city);
    }

    public void display(String name) {
        System.out.println(name + ":" + "name=" + name + ", age=" + age + "," + address);
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student s = (Student) super.clone();
        s.address = (Address) address.clone();
        return s;
    }
}

测试:

    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student("小明",20);
        s1.setAddress("安徽","合肥");
        Student s2 = (Student) s1.clone();
        System.out.println("S1:"+s1);
        System.out.println("s1.getName:"+s1.getName().hashCode());
        System.out.println("S2:"+s2);
        System.out.println("s2.getName:"+s2.getName().hashCode());

        s1.display("s1");
        s2.display("s2");
        s2.setAddress("安徽","安庆");
        s1.display("s1");
        s2.display("s2");
    }

输出结果:

S1:org.example.jvm.Student@2a84aee7
s1.getName:756703
S2:org.example.jvm.Student@a09ee92
s2.getName:756703
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=合肥]
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=安庆]

由输出结果可知,深拷贝后,不管是基础数据类型还是引用类型的成员变量,修改其值都不会相互造成影响。

注意:

但是这种做法有个弊端,这里我们Student类只有一个Address引用类型,而 Address 类没有,所以我们只用重写 Address 类的clone方法,但是如果 Address 类也存在一个引用类型,那么我们也要重写其clone方法,这样下去,有多少个引用类型,我们就要重写多少次,如果存在很多引用类型,那么代码量显然会很大,所以这种方法不太合适。

还有一种方式可以实现深拷贝:利用序列化

序列化是将对象写到流中便于传输,而反序列化则是把对象从流中读取出来。

这里写到流中的对象则是原始对象的一个拷贝,因为原始对象还存在 JVM 中,所以我们可以利用对象的序列化产生克隆对象,然后通过反序列化获取这个对象。

注意每个需要序列化的类都要实现 Serializable 接口,如果有某个属性不需要序列化,可以将其声明为 transient,即将其排除在克隆属性之外。

public class Address implements Serializable {

    private String province;
    private String city;

    public void setAddress(String province, String city) {
        this.province = province;
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address [province=" + province + ", city=" + city + "]";
    }
}
public class Student implements Serializable {

    private String name;
    private int age;
    private Address address;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.address = new Address();
    }

    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 void setAddress(String province, String city) {
        address.setAddress(province, city);
    }

    public void display(String name) {
        System.out.println(name + ":" + "name=" + name + ", age=" + age + "," + address);
    }

    //深度拷贝
    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

}

测试:

    public static void main(String[] args) throws Exception {
        Student s1 = new Student("小明",20);
        s1.setAddress("安徽","合肥");
        Student s2 = (Student) s1.deepClone();
        System.out.println("S1:"+s1);
        System.out.println("s1.getName:"+s1.getName().hashCode());
        System.out.println("S2:"+s2);
        System.out.println("s2.getName:"+s2.getName().hashCode());

        s1.display("s1");
        s2.display("s2");
        s2.setAddress("安徽","安庆");
        s1.display("s1");
        s2.display("s2");
    }

输出结果:

S1:org.example.jvm.Student@3f99bd52
s1.getName:756703
S2:org.example.jvm.Student@1f17ae12
s2.getName:756703
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=合肥]
s1:name=s1, age=20,Address [province=安徽, city=合肥]
s2:name=s2, age=20,Address [province=安徽, city=安庆]

因为序列化产生的是两个完全独立的对象,所有无论嵌套多少个引用类型,序列化都是能实现深拷贝的。

小结

至此,相信什么是深拷贝,什么是浅拷贝,相信你一定明白了。

你可能感兴趣的:(java基础,java,后端)