乐趣区

关于java:5张图搞懂Java引用拷贝浅拷贝深拷贝

jiezi

在开发、刷题、面试中，咱们可能会遇到将一个对象的属性赋值到另一个对象的状况，这种状况就叫做拷贝。拷贝与 Java 内存构造非亲非故，搞懂 Java 深浅拷贝是很必要的！

在对象的拷贝中，很多初学者可能搞不清到底是拷贝了援用还是拷贝了对象。在拷贝中这里就分为援用拷贝、浅拷贝、深拷贝进行讲述。

援用拷贝

援用拷贝会生成一个新的对象援用地址，然而两个最终指向仍然是同一个对象。如何更好的了解援用拷贝呢？很简略，就拿咱们人来说，通常有个姓名，然而不同场合、人物对咱们的叫法可能不同，但咱们很分明哪些名称都是属于 ” 我 ” 的！

当然，通过一个代码示例让大家领略一下(为了简便就不写 get、set 等办法)：

class Son {
    String name;
    int age;

    public Son(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class test {public static void main(String[] args) {Son s1 = new Son("son1", 12);
        Son s2 = s1;
        s1.age = 22;
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("s1 的 age:" + s1.age);
        System.out.println("s2 的 age:" + s2.age);
        System.out.println("s1==s2" + (s1 == s2));// 相等
    }
}
复制代码

输入的后果为：

Son@135fbaa4
Son@135fbaa4
s1 的 age:22
s2 的 age:22
true
复制代码

《2020 最新 Java 根底精讲视频教程和学习路线！》

浅拷贝

如何创立一个对象，将指标对象的内容复制过去而不是间接拷贝援用呢？

这里先讲一下 浅拷贝 ，浅拷贝会创立一个新对象，新对象和原对象自身没有任何关系， 新对象和原对象不等，然而新对象的属性和老对象雷同。具体能够看如下区别：

  • 如果属性是根本类型(int,double,long,boolean 等)，拷贝的就是根本类型的值；
  • 如果属性是援用类型，拷贝的就是内存地址（即复制援用但不复制援用的对象），因而如果其中一个对象扭转了这个地址，就会影响到另一个对象。

如果用一张图来形容一下浅拷贝，它应该是这样的：

如何实现浅拷贝呢？也很简略，就是在须要拷贝的类上实现 Cloneable 接口并重写其 clone()办法。

@Override
protected Object clone() throws CloneNotSupportedException {return super.clone();
}
复制代码

在应用的时候间接调用类的 clone()办法即可。具体案例如下：

class Father{
    String name;
    public Father(String name) {this.name=name;}
    @Override
    public String toString() {
        return "Father{" +
                "name='" + name + '''+'}';
    }
}
class Son implements Cloneable {
    int age;
    String name;
    Father father;
    public Son(String name,int age) {
        this.age=age;
        this.name = name;
    }
    public Son(String name,int age, Father father) {
        this.age=age;
        this.name = name;
        this.father = father;
    }
    @Override
    public String toString() {
        return "Son{" +
                "age=" + age +
                ", name='" + name + '''+", father="+ father +'}';
    }
    @Override
    protected Son clone() throws CloneNotSupportedException {return (Son) super.clone();}
}
public class test {public static void main(String[] args) throws CloneNotSupportedException {Father f=new Father("bigFather");
        Son s1 = new Son("son1",13);
        s1.father=f;
        Son s2 = s1.clone();
        
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("s1==s2:"+(s1 == s2));// 不相等
        System.out.println("s1.name==s2.name:"+(s1.name == s2.name));// 相等
        System.out.println();

        // 然而他们的 Father father 和 String name 的援用一样
        s1.age=12;
        s1.father.name="smallFather";//s1.father 援用未变
        s1.name="son222";// 相似 s1.name=new String("son222") 援用发生变化
        System.out.println("s1.Father==s2.Father:"+(s1.father == s2.father));// 相等
        System.out.println("s1.name==s2.name:"+(s1.name == s2.name));// 不相等
        System.out.println(s1);
        System.out.println(s2);
    }
}
复制代码

运行后果为：

Son{age=13, name='son1', father=Father{name='bigFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
s1==s2:false
s1.name==s2.name:true// 此时相等

s1.Father==s2.Father:true
s1.name==s2.name:false// 批改援用后不等
Son{age=12, name='son222', father=Father{name='smallFather'}}
Son{age=13, name='son1', father=Father{name='smallFather'}}
复制代码

不出意外，这种浅拷贝除了对象自身不同以外，各个零部件和关系和拷贝对象都是雷同的，就如同双胞胎一样，是两个人，然而其开始的样貌、各种关系 (父母亲人) 都是雷同的。须要留神 的是其中 name 初始 == 是相等的，是因为初始浅拷贝它们指向一个雷同的 String，而后 s1.name="son222" 则扭转援用指向。

深拷贝

对于上述的问题尽管拷贝的两个对象不同，但其外部的一些援用还是雷同的，怎么样相对的拷贝这个对象，使这个对象齐全独立于原对象呢？就应用咱们的深拷贝了。深拷贝：在对援用数据类型进行拷贝的时候，创立了一个新的对象，并且复制其内的成员变量。

在具体实现深拷贝上，这里提供两个形式，重写 clone()办法和序列法。

重写 clone()办法

如果应用重写 clone()办法实现深拷贝，那么要将类中所有自定义援用变量的类也去实现 Cloneable 接口实现 clone()办法。对于字符类能够创立一个新的字符串实现拷贝。

对于上述代码，Father 类实现 Cloneable 接口并重写 clone()办法。son 的 clone()办法须要对各个援用都拷贝一遍。

//Father clone()办法
@Override
protected Father clone() throws CloneNotSupportedException {return (Father) super.clone();}
//Son clone()办法
@Override
protected Son clone() throws CloneNotSupportedException {Son son= (Son) super.clone();// 待返回克隆的对象
    son.name=new String(name);
    son.father=father.clone();
    return son;
}
复制代码

其余代码不变，执行后果如下：

Son{age=13, name='son1', father=Father{name='bigFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
s1==s2:false
s1.name==s2.name:false

s1.Father==s2.Father:false
s1.name==s2.name:false
Son{age=12, name='son222', father=Father{name='smallFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
复制代码
序列化

能够发现这种形式实现了深拷贝。然而这种状况有个问题，如果援用数量或者层数太多了怎么办呢？

不可能去每个对象挨个写 clone()吧？那怎么办呢？借助序列化啊。

因为序列化后：将二进制字节流内容写到一个媒介（文本或字节数组），而后是从这个媒介读取数据，原对象写入这个媒介后拷贝给 clone 对象，原对象的批改不会影响 clone 对象，因为 clone 对象是从这个媒介读取。

相熟对象缓存的晓得咱们常常将 Java 对象缓存到 Redis 中，而后还可能从 Redis 中读取生成 Java 对象，这就用到序列化和反序列化。个别能够将 Java 对象存储为字节流或者 json 串而后反序列化成 Java 对象。因为序列化会贮存对象的属性然而 不会也无奈存储对象在内存中地址相干信息。所以在反序列化成 Java 对象时候会从新创立所有的援用对象。

在具体实现上，自定义的类 须要实现 Serializable 接口 。在须要深拷贝的类(Son) 中定义一个函数返回该类对象：

protected Son deepClone() throws IOException, ClassNotFoundException {
      Son son=null;
      // 在内存中创立一个字节数组缓冲区，所有发送到输入流的数据保留在该字节数组中
      // 默认创立一个大小为 32 的缓冲区
      ByteArrayOutputStream byOut=new ByteArrayOutputStream();
      // 对象的序列化输入
      ObjectOutputStream outputStream=new ObjectOutputStream(byOut);// 通过字节数组的形式进行传输
      outputStream.writeObject(this);  // 将以后 student 对象写入字节数组中

      // 在内存中创立一个字节数组缓冲区，从输出流读取的数据保留在该字节数组缓冲区
      ByteArrayInputStream byIn=new ByteArrayInputStream(byOut.toByteArray()); // 接管字节数组作为参数进行创立
      ObjectInputStream inputStream=new ObjectInputStream(byIn);
      son=(Son) inputStream.readObject(); // 从字节数组中读取
      return  son;
}
复制代码

应用时候调用咱们写的办法即可，其余不变，实现的成果为：

Son{age=13, name='son1', father=Father{name='bigFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
s1==s2:false
s1.name==s2.name:false

s1.Father==s2.Father:false
s1.name==s2.name:false
Son{age=12, name='son222', father=Father{name='smallFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}

链接：https://juejin.cn/post/690741…

退出移动版