深浅克隆面试题汇总——附详细答案
在开始学习深克隆和浅克隆以前，咱们先来看下面代码，有什么问题？java
class CloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
// 等号赋值（ 基本类型）
int number = 6;
int number2 = number;
// 修改 number2 的值
number2 = 9;
System.out.println("number：" + number);
System.out.println("number2：" + number2);
// 等号赋值（对象）
Dog dog = new Dog();
dog.name = "旺财";
dog.age = 5;
Dog dog2 = dog;
// 修改 dog2 的值
dog2.name = "大黄";
dog2.age = 3;
System.out.println(dog.name + "，" + dog.age + "岁");
System.out.println(dog2.name + "，" + dog2.age + "岁");
}
}
程序执行结果：git
number：6 number2：9 大黄，3岁 大黄，3岁
能够看出，若是使用等号复制时，对于值类型来讲，彼此之间的修改操做是相对独立的，而对于引用类型来讲，由于复制的是引用对象的内存地址，因此修改其中一个值，另外一个值也会跟着变化，原理以下图所示： 
所以为了防止这种问题的发生，就要使用对象克隆来解决引用类型复制的问题。github
1、浅克隆
浅克隆的默认实现方法是 clone()，实现代码以下：面试
class CloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
Dog dog = new Dog();
dog.name = "旺财";
dog.age = 5;
// 克隆
Dog dog3 = (Dog) dog.clone();
dog3.name = "小白";
dog3.age = 2;
System.out.println(dog.name + "，" + dog.age + "岁");
System.out.println(dog3.name + "，" + dog3.age + "岁");
}
}
class Dog implements Cloneable {
public String name;
public int age;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
程序执行结果：ide
旺财，5岁 小白，2岁
能够看出使用克隆就能够解决引用类型复制的问题了，原理以下图所示： 以上这种复制方式叫作浅克隆。 浅克隆的实现条件：须要克隆的对象必须实现 Cloneable 接口，并重写 clone() 方法，便可实现对此对象的克隆。 然而使用浅克隆也会存在一个问题，请参考如下代码。函数
class CloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
DogChild dogChild = new DogChild();
dogChild.name = "二狗";
Dog dog4 = new Dog();
dog4.name = "大黄";
dog4.dogChild = dogChild;
Dog dog5 = (Dog) dog4.clone();
dog5.name = "旺财";
dog5.dogChild.name = "狗二";
System.out.println("dog name 4："+dog4.name);
System.out.println("dog name 5："+dog5.name);
System.out.println("dog child name 4："+dog4.dogChild.name);
System.out.println("dog child name 5："+dog5.dogChild.name);
}
}
class Dog implements Cloneable {
public String name;
public DogChild dogChild;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class DogChild {
public String name;
}
程序执行结果：性能
dog name 4：大黄 dog name 5：旺财 dog child name 4：狗二 dog child name 5：狗二
也就是说浅克隆，只会复制对象的值类型，而不会复制对象的引用类型。缘由以下图所示： 要处理引用类型不被复制的问题，就要使用到深克隆。学习
2、深克隆
定义：深克隆就是复制整个对象信息，包含值类型和引用类型。 深克隆的实现方式一般包含如下两种。操作系统
- 序列化实现深克隆：先将原对象序列化到内存的字节流中，再从字节流中反序列化出刚刚存储的对象，这个新对象和原对象就不存在任何地址上的共享，这样就实现了深克隆。
- 全部引用类型都实现克隆：要复制对象的全部引用类型都要实现克隆，全部对象都是复制的新对象，从而实现了深克隆。
深克隆实现方式一：序列化code
实现思路：先将要拷贝对象写入到内存中的字节流中，而后再从这个字节流中读出刚刚存储的信息，做为一个新对象返回，那么这个新对象和原对象就不存在任何地址上的共享，天然实现了深拷贝。请参考如下代码：
class CloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
BirdChild birdChild = new BirdChild();
birdChild.name = "小小鸟";
Bird bird = new Bird();
bird.name = "小鸟";
bird.birdChild = birdChild;
// 使用序列化克隆对象
Bird bird2 = CloneUtils.clone(bird);
bird2.name = "黄雀";
bird2.birdChild.name = "小黄雀";
System.out.println("bird name:" + bird.name);
System.out.println("bird child name:" + bird.birdChild.name);
System.out.println("bird name 2:" + bird2.name);
System.out.println("bird child name 2:" + bird2.birdChild.name);
}
}
class CloneUtils {
public static <T extends Serializable> T clone(T obj) {
T cloneObj = null;
try {
//写入字节流
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bo);
oos.writeObject(obj);
oos.close();
//分配内存,写入原始对象,生成新对象
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());//获取上面的输出字节流
ObjectInputStream oi = new ObjectInputStream(bi);
//返回生成的新对象
cloneObj = (T) oi.readObject();
oi.close();
} catch (Exception e) {
e.printStackTrace();
}
return cloneObj;
}
}
程序执行结果：
bird name:小鸟 bird child name:小小鸟 bird name 2:黄雀 bird child name 2:小黄雀
深克隆实现方式二：全部引用类型都实现克隆
class SerializableTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ParrotChild parrotChild = new ParrotChild();
parrotChild.name = "小鹦鹉";
Parrot parrot = new Parrot();
parrot.name = "大鹦鹉";
parrot.parrotChild = parrotChild;
// 克隆
Parrot parrot2 = (Parrot) parrot.clone();
parrot2.name = "老鹦鹉";
parrot2.parrotChild.name = "少鹦鹉";
System.out.println("parrot name:" + parrot.name);
System.out.println("parrot child name:" + parrot.parrotChild.name);
System.out.println("parrot name 2:" + parrot2.name);
System.out.println("parrot child name 2:" + parrot2.parrotChild.name);
}
}
class Parrot implements Cloneable {
public String name;
public ParrotChild parrotChild;
@Override
protected Object clone() throws CloneNotSupportedException {
Parrot bird = (Parrot) super.clone();
bird.parrotChild = (ParrotChild) parrotChild.clone();
return bird;
}
}
class ParrotChild implements Cloneable {
public String name;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
程序执行结果：
parrot name:大鹦鹉 parrot child name:小鹦鹉 parrot name 2:老鹦鹉 parrot child name 2:少鹦鹉
3、克隆相关面试题
1.使用克隆有什么好处？
答：好处包含如下几点：
- 使用方便：假如要复制一个对象，但这个对象中的部分属性已经被修改过了，若是不使用克隆的话，须要给属性手动赋值，相比克隆而已麻烦不少；
- 性能高：查看 clone 方法能够知道，它是 native 方法，native 方法是原生函数，使用操做系统底层的语言实现的，所以执行效率更高；
- 隔离性：克隆能够确保对象操做时相互隔离。
clone() 源代码，以下图：
2.浅克隆和深克隆有什么区别？
答：区别主要在对引用类型的复制上，具体信息以下：
- 浅克隆：只会复制对象的值类型，而不会复制对象的引用类型；
- 深克隆：复制整个对象，包含值类型和引用类型。
3.如何实现浅克隆？
答：克隆的对象实现 Cloneable 接口，并重写 clone() 方法就能够实现浅克隆了。
4.如下代码执行的结果是？
import java.util.Arrays;
class CloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
CloneObj cloneObj = new CloneObj();
cloneObj.name = "老王";
cloneObj.age = 30;
cloneObj.sistersAge = new int[]{18, 19};
CloneObj cloneObj2 = (CloneObj) cloneObj.clone();
cloneObj2.name = "磊哥";
cloneObj2.age = 33;
cloneObj2.sistersAge[0] = 20;
System.out.println(cloneObj.name + "|" + cloneObj2.name);
System.out.println(cloneObj.age + "|" + cloneObj2.age);
System.out.println(Arrays.toString(cloneObj.sistersAge) + "|" + Arrays.toString(cloneObj2.sistersAge));
}
}
class CloneObj implements Cloneable {
public String name;
public int age;
public int[] sistersAge;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
答：执行结果以下。
老王|磊哥 30|33 [20, 19]|[20, 19]
5.深克隆如何实现？有几种实现方式？
答：通常实现方式有如下两种：
- 经过序列化实现深克隆（序列化实现方式：Java 原生序列化、JSON 序列化、Hessian 序列化）；
- 全部引用类型都实现克隆，从而实现深克隆。
6.为何不能直接使用 Object 的 Clone 方法，还要重写 clone() 方法以后才能实现克隆？
答：虽然全部类都是 Object 的子类，但由于 Object 中的 clone() 方法被声明为 protected 访问级别，因此非 java.lang 包下的其余类是不能直接使用的。所以要想实现克隆功能，就必须实现 Cloneable，并重写 clone() 方法才行。
7.序列化可不能够实现深克隆？实现的原理是什么？
答：先将原对象序列化到内存的字节流中，再从字节流中反序列化出刚刚存储的对象，这个新对象和原对象就不存在任何地址上的共享，这样就实现了深克隆。
4、总结
调用 Object 类中的 clone() 方法默认是浅克隆，浅克隆只能复制值类型，不能复制引用类型，所以更多的场景下咱们须要深克隆，深克隆一般的实现方式有两种：序列化方式或把全部的引用类型都实现克隆。
<hr>
特别说明：本文来自《Java面试题全解析》
相关文章
- 1. 深浅克隆面试题汇总——附详细答案
- 2. Java面试笔试题大汇总二(最全+详细答案)
- 3. 浅谈Java中的深克隆和浅克隆（阿里面试）
- 4. Java精选高频面试题汇总一，附答案，很详细
- 5. Redis面试题汇总（附答案），面试突击专用
- 6. Java 深克隆&浅克隆
- 7. 深克隆和浅克隆
- 8. 浅克隆和深克隆
- 9. 克隆，深克隆和浅克隆
- 10. Object克隆(深深浅浅)
- 更多相关文章...
- • Docker 资源汇总 - Docker教程
- • XML DOM 克隆节点 - XML DOM 教程
- • 算法总结-深度优先算法
- • 为了进字节跳动，我精选了29道Java经典算法题，带详细讲解
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 深浅克隆面试题汇总——附详细答案
- 2. Java面试笔试题大汇总二(最全+详细答案)
- 3. 浅谈Java中的深克隆和浅克隆（阿里面试）
- 4. Java精选高频面试题汇总一，附答案，很详细
- 5. Redis面试题汇总（附答案），面试突击专用
- 6. Java 深克隆&浅克隆
- 7. 深克隆和浅克隆
- 8. 浅克隆和深克隆
- 9. 克隆，深克隆和浅克隆
- 10. Object克隆(深深浅浅)