原创公众号 「bigsai」 专一于Java和数据结构与算法的分享
文章收录在github/bigsai-algorithm 可珍藏
在开发、刷题、面试中，咱们可能会遇到将一个对象的属性赋值到另一个对象的状况，这种状况就叫做拷贝。拷贝与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@135fbaa4Son@135fbaa4s1的age:22s2的age:22true浅拷贝
如何创立一个对象，将指标对象的内容复制过去而不是间接拷贝援用呢？
这里先讲一下浅拷贝，浅拷贝会创立一个新对象，新对象和原对象自身没有任何关系，新对象和原对象不等，然而新对象的属性和老对象雷同。具体能够看如下区别：
- 如果属性是根本类型(int,double,long,boolean等)，拷贝的就是根本类型的值；
- 如果属性是援用类型，拷贝的就是内存地址（即复制援用但不复制援用的对象） ，因而如果其中一个对象扭转了这个地址，就会影响到另一个对象。
如果用一张图来形容一下浅拷贝，它应该是这样的：
如何实现浅拷贝呢？也很简略，就是在须要拷贝的类上实现Cloneable接口并重写其clone()办法。
@Overrideprotected 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:falses1.name==s2.name:true//此时相等s1.Father==s2.Father:trues1.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()办法@Overrideprotected Father clone() throws CloneNotSupportedException { return (Father) super.clone();}//Son clone()办法@Overrideprotected 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:falses1.name==s2.name:falses1.Father==s2.Father:falses1.name==s2.name:falseSon{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:falses1.name==s2.name:falses1.Father==s2.Father:falses1.name==s2.name:falseSon{age=12, name='son222', father=Father{name='smallFather'}}Son{age=13, name='son1', father=Father{name='bigFather'}}写在最初
原创不易，bigsai我请思否两件事帮忙一下:
- 点赞反对一下， 您的必定是我在思否创作的源源能源。
- 微信搜寻「bigsai」，关注我的公众号(新人求反对)，不仅免费送你电子书，我还会第一工夫在公众号分享常识技术。加我还可拉你进力扣打卡群一起打卡LeetCode。
如果本篇对你有帮忙，还请点个赞，如果您有更好的见解，能够在评论区交换！