前言
本文代码中有用到一些注解，主要是 Lombok 与 junit 用于简化代码。
主要是看到一堆代码会很乱，这样理解更清晰。如果没用过不用太过纠结。
对象的拷贝（克隆）是一个非常高频的操作，主要有以下三种方式：
添加 vx 小助手：xiehuangbao1123 领取 java 全套学习资料
因为 Java 没有指针的概念，或者说是不需要我们去操心，这让我们省去了很多麻烦，但相应的，对于对象的引用、拷贝有时候就会有些懵逼，藏下一些很难发现的 bug。
为了避免这些 bug，理解这三种操作的作用与区别就是关键。
直接赋值
用等于号直接赋值是我们平时最常用的一种方式。
它的特点就是直接引用等号右边的对象
先来看下面的例子
先创建一个 Person 类
@Data@AllArgsConstructor @ToStringpublic class Person{ private String name; private int age; private Person friend;}
复制代码
测试
@Testpublic void test() { Person friend =new Person("老王",30,null); Person person1 = new Person("张三", 20, null); Person person2 = person1; System.out.println("person1: " + person1); System.out.println("person2: " + person2 + "\n"); person1.setName("张四"); person1.setAge(25); person1.setFriend(friend); System.out.println("person1: " + person1); System.out.println("person2: " + person2);}
复制代码
结果
person1: Person(name=张三, age=20, friend=null)person2: Person(name=张三, age=20, friend=null)
person1: Person(name=张四, age=25, friend=Person(name=老王, age=30, friend=null))person2: Person(name=张四, age=25, friend=Person(name=老王, age=30, friend=null))
复制代码
分析：可以看到通过直接赋值进行拷贝，其实就只是单纯的对前对象进行引用。
如果这些对象都是 基础对象 当然没什么问题，但是如果对象进行操作，相当于 两个对象同属一个实例 。
拷贝
直接赋值虽然方便，但是很多时候并不是我们想要的结果，很多时候我们需要的是两个看似一样但是完全独立的两个对象。这种时候我们就需要用到一个方法 clone()clone() 并不是一个可以直接使用的方法，需要先实现Cloneable接口，然后重写它才能使用。
protected native Object clone() throws CloneNotSupportedException;
复制代码
clone() 方法被native关键字修饰， native 关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是系统或者其他语言来实现。
浅拷贝
浅拷贝可以实现对象克隆，但是存在一些缺陷。
定义：
举例
光看定义不太好一下子理解，上代码看例子。
我们先来修改一下 Person 类，实现Cloneable接口，重写clone()方法，其实很简单，只需要用 super 调用一下即可
@Data@AllArgsConstructor@ToStringpublic class Person implements Cloneable { private String name; private int age; private Friend friend; @Override public Object clone() { try { return super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return null; }}
------- @Data@AllArgsConstructorpublic class Friend { private String Name;}
复制代码
测试
@Testpublic void test() { Person person1 = new Person("张三", 20, "老王"); Person person2 = (Person) person1.clone();
System.out.println("person1: " + person1); System.out.println("person2: " + person2 + "\n"); person1.setName("张四"); person1.setAge(25); person1.setFriend("小王"); System.out.println("person1: " + person1); System.out.println("person2: " + person2);}
复制代码
结果
person1: Person(name=张三, age=20, friend=Friend(Name=老王))person2: Person(name=张三, age=20, friend=Friend(Name=老王))
person1: Person(name=张四, age=25, friend=Friend(Name=小王))person2: Person(name=张三, age=20, friend=Friend(Name=小王))
复制代码
可以看到， name age 基本对象属性并没改变，而friend引用对象熟悉变了。
原理 Java 浅拷贝的原理其实是把原对象的 各个属性的地址 拷贝给新对象。
注意我说的是 各个属性 ， 就算是基础对象属性其实也是拷贝的地址 。
你可能有点晕了，都是拷贝了地址，为什么修改了person1对象的 name age 属性值，person2对象的 name age 属性值没有改变呢？我们一步步来，拿 name 属性来说明：
String、Integer 等包装类都是 不可变的对象
当需要修改不可变对象的值时，需要在内存中 生成一个新的对象 来存放新的值
然后将原来的引用指向新的地址
我们修改了 person1 对象的 name 属性值， person1 对象的 name 字段指向了内存中 新的 String 对象
我们并没有改变 person2 对象的 name 字段的指向，所以 person2 对象的 name 还是指向内存中 原来的 String 地址
这个图已经很清晰的展示了其中的过程，因为 person1 对象改变 friend 时是改变的引用对象的属性，并不是新建立了一个对象进行替换，原本老王的消失了，变成了小王。所以 person2 也跟着改变了。
深拷贝
深拷贝就是我们拷贝的初衷了，无论是值类型还是引用类型都会完完全全的拷贝一份，在内存中生成一个新的对象。
拷贝对象和被拷贝对象没有任何关系，互不影响。
深拷贝相比于浅拷贝速度较慢并且花销较大。
简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。
因为 Java 本身的特性，对于不可变的基本值类型，无论如何在内存中都是只有一份的。
所以对于不可变的基本值类型，深拷贝跟浅拷贝一样，不过并不影响什么。实现：想要实现深拷贝并不难，只需要在浅拷贝的基础上进行一点修改即可。给friend添加一个 clone() 方法。在 Person 类的 clone() 方法调用 friend 的clone()方法，将friend也复制一份即可。
@Data@ToStringpublic class Person implements Cloneable { private String name; private int age; private Friend friend;
public Person(String name, int age, String friend) { this.name = name; this.age = age; this.friend = new Friend(friend); }
public void setFriend(String friend) { this.friend.setName(friend); }
@Override public Object clone() { try { Person person = (Person)super.clone(); person.friend = (Friend) friend.clone(); return person; } catch (CloneNotSupportedException e) { e.printStackTrace(); } return null; }}
------ @Data@AllArgsConstructorpublic class Friend implements Cloneable{ private String Name;
@Override public Object clone() throws CloneNotSupportedException { return super.clone(); }}
复制代码
测试
@Testpublic void test() {Person person1 = new Person("张三", 20, "老王");Person person2 = (Person) person1.clone();
System.out.println("person1: " + person1);System.out.println("person2: " + person2 + "\n");person1.setName("张四");person1.setAge(25);person1.setFriend("小王");System.out.println("person1: " + person1);System.out.println("person2: " + person2);}
复制代码
结果
person1: Person(name=张三, age=20, friend=Friend(Name=老王))person2: Person(name=张三, age=20, friend=Friend(Name=老王))
person1: Person(name=张四, age=25, friend=Friend(Name=小王))person2: Person(name=张三, age=20, friend=Friend(Name=老王))
复制代码
分析：
可以看到这次是真正的完全独立了起来。
需要注意的是， 如果 Friend 类本身也存在引用类型 ，则需要在 Friend 类中的 clone() ，也去调用其引用类型的 clone() 方法，就如是 Person 类中那样，对！就是套娃！
所以对于存在多层依赖关系的对象，实现 Cloneable 接口重写 clone() 方法就显得有些笨拙了。
这里我们在介绍一种方法： 利用序列化实现深拷贝
Serializable 实现深拷贝
修改 Person 和 Friend ，实现Serializable接口
@Data@ToStringpublic class Person implements Serializable { // ......同之前 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(); }}
--- @Data@AllArgsConstructorpublic class Friend implements Serializable { private String Name;}
复制代码
测试
@Testpublic void test() { Person person1 = new Person("张三", 20, "老王"); Person person2 = null; try { person2 = (Person) person1.deepClone(); } catch (Exception e) { e.printStackTrace(); }
System.out.println("person1: " + person1); System.out.println("person2: " + person2 + "\n"); person1.setName("张四"); person1.setAge(25); person1.setFriend("小王"); System.out.println("person1: " + person1); System.out.println("person2: " + person2);}
复制代码
结果
person1: Person(name=张三, age=20, friend=Friend(Name=老王))person2: Person(name=张三, age=20, friend=Friend(Name=老王))
person1: Person(name=张四, age=25, friend=Friend(Name=小王))person2: Person(name=张三, age=20, friend=Friend(Name=老王))
复制代码
只要将会被复制到的引用对象标记 Serializable 接口，通过序列化到方式即可实现深拷贝。
原理：
对象被序列化成流后，因为写在流里的是 对象的一个拷贝 ，而 原对象仍然存在于虚拟机里面 。
通过反序列化就可以获得一个完全相同的拷贝。
利用这个特性就实现了对象的深拷贝。
总结
直接赋值是将 新的对象 指向 原对象所指向的实例 ，所以一旦有所修改，两个对象会一起变。
浅拷贝是把原对象属性的 地址 传给新对象，对于不可变的基础类型，实现了二者的分离，但对于引用对象，二者还是会一起改变。
深拷贝是真正的完全拷贝，二者没有关系。实现深拷贝时如果存在多层依赖关系，可以采用序列化的方式来进行实现。
对于 Serializable 接口、 Cloneable 接口，其实都是相当于一个标记，点进去看源码，其实他们是一个空接口。
最后，感谢大家的观看，谢谢大家的支持，能三连关注收藏就最好啦，祝各位面试必过，升职加薪，早日升职加薪！
评论