面试题：深拷贝、浅拷贝、引用拷贝的区别

目录

• 引用拷贝
  
• 浅拷贝
  
• 深拷贝
  
• 小结
  

作者：小牛呼噜噜 | https://xiaoniuhululu.com
计算机内功、JAVA底层、面试相关资料等更多精彩文章在公众号「小牛呼噜噜 」

引用拷贝

引用拷贝: 引用拷贝不会在堆上创建一个新的对象，只 会在栈上生成一个新的引用地址，最终指向依然是堆上的同一个对象。

1. //实体类
2. public class Person{
3.     public String name;//姓名
4.     public int height;//身高
5.     public StringBuilder something;
7.     public String getName() {
8.         return name;
9.     }
11.     public void setName(String name) {
12.         this.name = name;
13.     }
15.     public int getHeight() {
16.         return height;
17.     }
19.     public void setHeight(int height) {
20.         this.height = height;
21.     }
23.     public StringBuilder getSomething() {
24.         return something;
25.     }
27.     public void setSomething(StringBuilder something) {
28.         this.something = something;
29.     }
31.     public Person(String name, int height, StringBuilder something) {
32.         this.name = name;
33.         this.height = height;
34.         this.something = something;
35.     }
37. }
39. //测试类
40. public class copyTest {
41.     public static void main(String[] args) {
42.         Person p1 = new Person("小张", 180, new StringBuilder("今天天气很好"));
43.         Person p2 = p1;
45.         System.out.println("对象是否相等："+ (p1 == p2));
46.         System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
47.         System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
50.         // change
51.         p1.name="小王";
52.         p1.height = 200;
53.         p1.something.append(",适合出去玩");
54.         System.out.println("...after p1 change....");
56.         System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
57.         System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
59.     }
60. }

复制代码

结果：

对象是否相等：true
p1 属性值=小张,180,今天天气很好
p2 属性值=小张,180,今天天气很好
...after p1 change....
p1 属性值=小王,200,今天天气很好,适合出去玩
p2 属性值=小王,200,今天天气很好,适合出去玩

before change:

after change:

我们可以看出 由于2个引用p1,p2 都是指向堆中同一个对象，所以2个对象是相等的，修改了对象p1，会影响到对象p2
需要注意的

• name属性，虽然她是引用类型，但她同时也是String类型，不可变，对其修改，JVM会默认在堆上创建新的内存空间，再重新赋值
  
• int weight=180; 是成员变量，存放在堆中，不是所有的基本类型变量 都存放在JVM栈中
  

注意与这篇文章得区分开来 https://mp.weixin.qq.com/s/6qRspyLAsoBxttGwGtxsAA， int num1 = 10;是基本类型的局部变量，存放在栈中
浅拷贝

浅拷贝 ：浅拷贝会在堆上创建一个新的对象，新对象和原对象不等，但是新对象的属性和老对象相同。
其中：

• 如果属性是基本类型(int,double,long,boolean等)，拷贝的就是基本类型的值。
  
• 如果属性是引用类型(除了基本类型都是引用类型)，拷贝的就是引⽤数据类型变量的地址值，⽽对于引⽤类型变量指向的堆中的对象不会拷贝。
  

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

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

复制代码

在使用的时候直接调用类的clone()方法即可

1. //实体类 继承Cloneable
2. public class Person implements Cloneable{
3.     public String name;//姓名
4.     public int height;//身高
5.     public StringBuilder something;
7.     public String getName() {
8.         return name;
9.     }
11.     public void setName(String name) {
12.         this.name = name;
13.     }
15.     public int getHeight() {
16.         return height;
17.     }
19.     public void setHeight(int height) {
20.         this.height = height;
21.     }
23.     public StringBuilder getSomething() {
24.         return something;
25.     }
27.     public void setSomething(StringBuilder something) {
28.         this.something = something;
29.     }
31.     public Person(String name, int height, StringBuilder something) {
32.         this.name = name;
33.         this.height = height;
34.         this.something = something;
35.     }
39.     @Override
40.     public Person clone() throws CloneNotSupportedException {
41.         return (Person) super.clone();
42.     }
44. }
46. //测试类
47. public class shallowCopyTest {
49.     public static void main(String[] args) throws CloneNotSupportedException {
50.         Person p1 = new Person("小张", 180, new StringBuilder("今天天气很好"));
51.         Person p2 = p1.clone();
53.         System.out.println("对象是否相等："+ (p1 == p2));
54.         System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
55.         System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
58.         // change
59.         p1.setName("小王");
60.         p1.setHeight(200);
61.         p1.getSomething().append(",适合出去玩");
62.         System.out.println("...after p1 change....");
64.         System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
65.         System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
67.     }
68. }

复制代码

结果：

对象是否相等：false
p1 属性值=小张,180,今天天气很好
p2 属性值=小张,180,今天天气很好
...after p1 change....
p1 属性值=小王,200,今天天气很好,适合出去玩
p2 属性值=小张,180,今天天气很好,适合出去玩

before change:

after change:

我们可以看出：

• 当我们修改对象p1的weight属性时，由于p2的height属性 是直接复制修改前的p1的height属性，所以还是180。
  
• 当我们修改对象p1的name属性 时，String name指向一个新的内存空间，但对象p2的name还是指向旧的内存空间，所以对象p2的name属性还是"小张"。
  
• 由于对象p1的something属性和对象p2的something属性指向是同一个内存空间，当我们修改对象p1的something属性，会影响到对象p2的something属性，所以对象p2的something属性变为"今天天气很好,适合出去玩"。
  

深拷贝

深拷贝 ：完全拷贝⼀个对象，在堆上创建一个新的对象，拷贝被拷贝对象的成员变量的值，同时堆中的对象也会拷贝。
需要重写clone方法

1.     @Override
2.     public Person clone() throws CloneNotSupportedException {
3.         //return (Person) super.clone();
4.         Person person = (Person) super.clone();
5.         person.setSomething( new StringBuilder(person.getSomething()));//单独为引用类型clone
6.         return person;
7.     }

复制代码

shallowCopyTest测试类的结果：

对象是否相等：false
p1 属性值=小张,180,今天天气很好
p2 属性值=小张,180,今天天气很好
...after p1 change....
p1 属性值=小王,200,今天天气很好,适合出去玩
p2 属性值=小张,180,今天天气很好

这时候对象p1和对象p2互不干扰了
before change:

after change:

但这样也有个小问题，对象每有一个引用类型，我们都得重写其clone方法，这样会非常麻烦，因此我们还可以借助序列化来实现对象的深拷贝

1. //实体类 继承Cloneable
2. public class Person implements Serializable{
3.     public String name;//姓名
4.     public int height;//身高
5.     public StringBuilder something;
7. ...//省略 getter setter
10.     public Object deepClone() throws Exception{
11.         // 序列化
12.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
13.         ObjectOutputStream oos = new ObjectOutputStream(bos);
14.    
15.         oos.writeObject(this);
16.    
17.         // 反序列化
18.         ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
19.         ObjectInputStream ois = new ObjectInputStream(bis);
20.    
21.         return ois.readObject();
22.     }
24. }
26. //测试类，这边类名笔者就不换了，在之前的基础上改改
27. public class shallowCopyTest {
29.     public static void main(String[] args) throws Exception {
30.         Person p1 = new Person("小张", 180, new StringBuilder("今天天气很好"));
31.         Person p2 = (Person)p1.deepClone();
33.         System.out.println("对象是否相等："+ (p1 == p2));
34.         System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
35.         System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
38.         // change
39.         p1.setName("小王");
40.         p1.setHeight(200);
41.         p1.getSomething().append(",适合出去玩");
42.         System.out.println("...after p1 change....");
44.         System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
45.         System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
47.     }
48. }

复制代码

这样也会得到深拷贝的结果
小结

• 引用拷贝: 引用拷贝不会在堆上创建一个新的对象，只 会在栈上生成一个新的引用地址，最终指向依然是堆上的同一个对象。
  
• 浅拷贝 ：浅拷贝会在堆上创建一个新的对象，新对象和原对象不等，但是新对象的属性和老对象相同。
  

其中：

• 如果属性是基本类型(int,double,long,boolean等)，拷贝的就是基本类型的值。
  
• 如果属性是引用类型(除了基本类型都是引用类型)，拷贝的就是引⽤数据类型变量的地址值，⽽对于引⽤类型变量指向的堆中的对象不会拷贝。
  

• 深拷贝 ：完全拷贝⼀个对象，在堆上创建一个新的对象，拷贝被拷贝对象的成员变量的值，同时堆中的对象也会拷贝。
  

参考资料：
https://blog.csdn.net/JingLxian/article/details/106337395
https://www.cnblogs.com/hithlb/p/4872373.html
很感谢你能看到最后，如果喜欢的话，欢迎关注点赞收藏转发，谢谢！更多精彩的文章


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！