刷题、面试中,我们可能会遇到将一个对象的属性赋值到另一个对象的情况,这种情况就叫做拷贝。拷贝与Java内存结构息息相关,搞懂Java深浅拷贝是很必要的!

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

引用拷贝

引用拷贝会生成一个新的对象引用地址,但是两个最终指向依然是同一个对象。如何更好的理解引用拷贝呢?很简单,就拿我们人来说,通常有个姓名,但是不同场合、人物对我们的叫法可能不同,但我们很清楚哪些名称都是属于"我"的!

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

  1. class Son {
  2. String name;
  3. int age;
  4. public Son(String name, int age) {
  5. this.name = name;
  6. this.age = age;
  7. }
  8. }
  9. public class test {
  10. public static void main(String[] args) {
  11. Son s1 = new Son("son1", 12);
  12. Son s2 = s1;
  13. s1.age = 22;
  14. System.out.println(s1);
  15. System.out.println(s2);
  16. System.out.println("s1的age:" + s1.age);
  17. System.out.println("s2的age:" + s2.age);
  18. System.out.println("s1==s2" + (s1 == s2));//相等
  19. }
  20. }

输出的结果为:

  1. Son@135fbaa4
  2. Son@135fbaa4
  3. s1的age:22
  4. s2的age:22
  5. true

浅拷贝

如何创建一个对象,将目标对象的内容复制过来而不是直接拷贝引用呢?

这里先讲一下浅拷贝,浅拷贝会创建一个新对象,新对象和原对象本身没有任何关系,新对象和原对象不等,但是新对象的属性和老对象相同。具体可以看如下区别:

  • 如果属性是基本类型(int,double,long,boolean等),拷贝的就是基本类型的值;

  • 如果属性是引用类型,拷贝的就是内存地址(即复制引用但不复制引用的对象) ,因此如果其中一个对象改变了这个地址,就会影响到另一个对象。

如果用一张图来描述一下浅拷贝,它应该是这样的:

如何实现浅拷贝呢?也很简单,就是在需要拷贝的类上实现Cloneable接口并重写其clone()方法。

  1. @Override
  2. protected Object clone() throws CloneNotSupportedException {
  3. return super.clone();
  4. }

在使用的时候直接调用类的clone()方法即可。具体案例如下:

  1. class Father{
  2. String name;
  3. public Father(String name) {
  4. this.name=name;
  5. }
  6. @Override
  7. public String toString() {
  8. return "Father{" +
  9. "name='" + name + '\'' +
  10. '}';
  11. }
  12. }
  13. class Son implements Cloneable {
  14. int age;
  15. String name;
  16. Father father;
  17. public Son(String name,int age) {
  18. this.age=age;
  19. this.name = name;
  20. }
  21. public Son(String name,int age, Father father) {
  22. this.age=age;
  23. this.name = name;
  24. this.father = father;
  25. }
  26. @Override
  27. public String toString() {
  28. return "Son{" +
  29. "age=" + age +
  30. ", name='" + name + '\'' +
  31. ", father=" + father +
  32. '}';
  33. }
  34. @Override
  35. protected Son clone() throws CloneNotSupportedException {
  36. return (Son) super.clone();
  37. }
  38. }
  39. public class test {
  40. public static void main(String[] args) throws CloneNotSupportedException {
  41. Father f=new Father("bigFather");
  42. Son s1 = new Son("son1",13);
  43. s1.father=f;
  44. Son s2 = s1.clone();
  45. System.out.println(s1);
  46. System.out.println(s2);
  47. System.out.println("s1==s2:"+(s1 == s2));//不相等
  48. System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//相等
  49. System.out.println();
  50. //但是他们的Father father 和String name的引用一样
  51. s1.age=12;
  52. s1.father.name="smallFather";//s1.father引用未变
  53. s1.name="son222";//类似 s1.name=new String("son222") 引用发生变化
  54. System.out.println("s1.Father==s2.Father:"+(s1.father == s2.father));//相等
  55. System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//不相等
  56. System.out.println(s1);
  57. System.out.println(s2);
  58. }
  59. }

运行结果为:

  1. Son{age=13, name='son1', father=Father{name='bigFather'}}
  2. Son{age=13, name='son1', father=Father{name='bigFather'}}
  3. s1==s2:false
  4. s1.name==s2.name:true//此时相等
  5. s1.Father==s2.Father:true
  6. s1.name==s2.name:false//修改引用后不等
  7. Son{age=12, name='son222', father=Father{name='smallFather'}}
  8. Son{age=13, name='son1', father=Father{name='smallFather'}}

不出意外,这种浅拷贝除了对象本身不同以外,各个零部件和关系和拷贝对象都是相同的,就好像双胞胎一样,是两个人,但是其开始的样貌、各种关系(父母亲人)都是相同的。需要注意的是其中name初始

==是相等的,是因为初始浅拷贝它们指向一个相同的String,而后s1.name="son222" 则改变引用指向。

深拷贝

对于上述的问题虽然拷贝的两个对象不同,但其内部的一些引用还是相同的,怎么样绝对的拷贝这个对象,使这个对象完全独立于原对象呢?就使用我们的深拷贝了。深拷贝:在对引用数据类型进行拷贝的时候,创建了一个新的对象,并且复制其内的成员变量。

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

重写clone()方法

如果使用重写clone()方法实现深拷贝,那么要将类中所有自定义引用变量的类也去实现Cloneable接口实现clone()方法。对于字符类可以创建一个新的字符串实现拷贝。

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

  1. //Father clone()方法
  2. @Override
  3. protected Father clone() throws CloneNotSupportedException {
  4. return (Father) super.clone();
  5. }
  6. //Son clone()方法
  7. @Override
  8. protected Son clone() throws CloneNotSupportedException {
  9. Son son= (Son) super.clone();//待返回克隆的对象
  10. son.name=new String(name);
  11. son.father=father.clone();
  12. return son;
  13. }

其他代码不变,执行结果如下:

  1. Son{age=13, name='son1', father=Father{name='bigFather'}}
  2. Son{age=13, name='son1', father=Father{name='bigFather'}}
  3. s1==s2:false
  4. s1.name==s2.name:false
  5. s1.Father==s2.Father:false
  6. s1.name==s2.name:false
  7. Son{age=12, name='son222', father=Father{name='smallFather'}}
  8. Son{age=13, name='son1', father=Father{name='bigFather'}}
序列化

可以发现这种方式实现了深拷贝。但是这种情况有个问题,如果引用数量或者层数太多了怎么办呢?

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

因为序列化后:将二进制字节流内容写到一个媒介(文本或字节数组),然后是从这个媒介读取数据,原对象写入这个媒介后拷贝给clone对象,原对象的修改不会影响clone对象,因为clone对象是从这个媒介读取。

熟悉对象缓存的知道我们经常将Java对象缓存到Redis中,然后还可能从Redis中读取生成Java对象,这就用到序列化和反序列化。一般可以将Java对象存储为字节流或者json串然后反序列化成Java对象。因为序列化会储存对象的属性但是不会也无法存储对象在内存中地址相关信息。所以在反序列化成Java对象时候会重新创建所有的引用对象。

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

  1. protected Son deepClone() throws IOException, ClassNotFoundException {
  2. Son son=null;
  3. //在内存中创建一个字节数组缓冲区,所有发送到输出流的数据保存在该字节数组中
  4. //默认创建一个大小为32的缓冲区
  5. ByteArrayOutputStream byOut=new ByteArrayOutputStream();
  6. //对象的序列化输出
  7. ObjectOutputStream outputStream=new ObjectOutputStream(byOut);//通过字节数组的方式进行传输
  8. outputStream.writeObject(this);  //将当前student对象写入字节数组中
  9. //在内存中创建一个字节数组缓冲区,从输入流读取的数据保存在该字节数组缓冲区
  10. ByteArrayInputStream byIn=new ByteArrayInputStream(byOut.toByteArray()); //接收字节数组作为参数进行创建
  11. ObjectInputStream inputStream=new ObjectInputStream(byIn);
  12. son=(Son) inputStream.readObject(); //从字节数组中读取
  13. return  son;
  14. }

使用时候调用我们写的方法即可,其他不变,实现的效果为:

  1. Son{age=13, name='son1', father=Father{name='bigFather'}}
  2. Son{age=13, name='son1', father=Father{name='bigFather'}}
  3. s1==s2:false
  4. s1.name==s2.name:false
  5. s1.Father==s2.Father:false
  6. s1.name==s2.name:false
  7. Son{age=12, name='son222', father=Father{name='smallFather'}}
  8. Son{age=13, name='son1', father=Father{name='bigFather'}}

一文搞懂Java引用拷贝、深拷贝、浅拷贝的更多相关文章

  1. 一文搞懂Java引用拷贝、浅拷贝、深拷贝

    微信搜一搜 「bigsai」 专注于Java和数据结构与算法的铁铁 文章收录在github/bigsai-algorithm 在开发.刷题.面试中,我们可能会遇到将一个对象的属性赋值到另一个对象的情况 ...

  2. 一文搞懂 Java 线程中断

    在之前的一文<如何"优雅"地终止一个线程>中详细说明了 stop 终止线程的坏处及如何优雅地终止线程,那么还有别的可以终止线程的方法吗?答案是肯定的,它就是我们今天要分 ...

  3. 一文搞懂Java环境,轻松实现Hello World!

    在上篇文章中,我们介绍了Java自学大概的路线.然而纸上得来终觉浅,今天我们教大家写第一个java demo.(ps:什么是demo?Demo的中文含意为“示范",Demo源码可以理解为某种 ...

  4. 夯实Java基础系列17:一文搞懂Java多线程使用方式、实现原理以及常见面试题

    本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...

  5. 夯实Java基础系列19:一文搞懂Java集合类框架,以及常见面试题

    本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...

  6. 一文搞懂--Java中重写equals方法为什么要重写hashcode方法?

    Java中重写equals方法为什么要重写hashcode方法? 直接看下面的例子: 首先我们只重写equals()方法 public class Test { public static void ...

  7. 一文搞懂Java/Spring/Dubbo框架中的SPI机制

    几天前和一位前辈聊起了Spring技术,大佬突然说了SPI,作为一个熟练使用Spring的民工,心中一紧,咱也不敢说不懂,而是在聊完之后赶紧打开了浏览器,开始的学习之路,所以也就有了这篇文章.废话不多 ...

  8. 一文搞懂 Java 中的枚举,写得非常好!

    知识点 概念 enum的全称为 enumeration, 是 JDK 1.5 中引入的新特性. 在Java中,被 enum关键字修饰的类型就是枚举类型.形式如下: enum Color { RED, ...

  9. 一文彻底搞懂Java中的环境变量

    一文搞懂Java环境变量 记得刚接触Java,第一件事就是配环境变量,作为一个初学者,只知道环境变量怎样配,在加上各种IDE使我们能方便的开发,而忽略了其本质的东西,只知其然不知其所以然,随着不断的深 ...

随机推荐

  1. 第14.2节 HTML知识简介

    一. HTML语言 HTML 指的是超文本标记语言 (Hyper Text Markup Language),它不是一种编程语言,而是一种使用一套标记标签(markup tag)来标记元素作用的标记语 ...

  2. 第二章、PyQt5应用构建详细过程介绍

    老猿Python博文目录 老猿Python博客地址 一.引言 在上节<第一章.PyQt的简介.安装与配置>介绍了PyQt5及其安装和配置过程,本节将编写一个简单的PyQt5应用,介绍基本的 ...

  3. JQuery获取父,子,兄弟节点

    jQuery.parent(expr) // 查找父节点,可以传入expr进行过滤,比如$("span").parent()或者$("span").parent ...

  4. Echarts的食用方式

    写在前面: 最近项目中用到了Echarts做趋势图,博主通过万能的度娘研究了一下.Echarts字段的使用基本都写在代码注释里了,这是博主的第一篇博客,如果哪里写的不好望大家见谅,最后希望本篇博客对大 ...

  5. js setTimeout运行机制

    在开始之前先看个面试例子 为什么会是0 1 2 2,而不是 0 0 1 1 再来看个例子 输出结果是4个undefined,为何不是1,2,3,4? 这是为什么呢,这是因为setTimeout是异步的 ...

  6. qq 表情库

    ![/qq](https://cdn.luogu.com.cn/upload/pic/62224.png) ![/cy](https://cdn.luogu.com.cn/upload/pic/622 ...

  7. 【C++】C++ new和malloc到底哪里不一样

    作者:李春港 出处:https://www.cnblogs.com/lcgbk/p/14118782.html 目录 一.前言 二.new和malloc两者的区别 2.1 属性的区别 2.2 使用上的 ...

  8. MySQL事务(二)事务隔离的实现原理:一致性读

    今天我们来学习一下MySQL的事务隔离是如何实现的.如果你对事务以及事务隔离级别还不太了解的话,这里左转. 好的,下面正式进入主题.事务隔离级别有4种:读未提交.读提交.可重复读和串行化.首先我们来说 ...

  9. GitLab的基本了解和使用

    使用前提 GitLab账号 安装好git VSCODE && 配置GitPath 在vscode里配置GitPath file-preferences-setting 在search ...

  10. Jmeter(2)基础知识

    一.Jmeter测试计划 1.测试计划用来描述一个性能/接口测试的脚本和场景设计 独立运行每个线程组:用于控制测试计划中的多个线程组的执行顺序.不勾选时,默认各线程组并行.随机执行. 主线程结束后运行 ...