文章目录
- 一、浅拷贝和深拷贝概念引出
- 1.1、概念
- 1.2、示例代码
- 二、浅拷贝
- 2.1、概念
- 2.2、浅拷贝区别于深拷贝
- 2.3、看图理解
- 2.4、实例代码
- 三、深拷贝
- 3.1、概念提出
- 3.2、jvm层面原理理解
- 3.3、深拷贝实现方法
- 3.4、实例代码
一、浅拷贝和深拷贝概念引出
1.1、概念
浅拷贝和深拷贝都是针对对象复制来说的，之所以有浅拷贝和深拷贝是由于原型设计模式这个概念上是对一个实例化对象时，若是需要属性值一样的多个对象时，就需要对一个对象进行各个属性值复制，也就是对象拷贝（举个栗子，比如克隆🐏，🐏是怎么看都是一样的，但是却是两只🐏)。对象的拷贝分浅拷贝和深拷贝，但是啥是浅或深拷贝呢，不急，下面我一一解释。
对象拷贝的方法有很多，其中全部自己手写可以，使用Object.clone()也可，但是若是不再加以自己的控制，我们只能进行普通的浅拷贝。
1.2、示例代码
以下就是普通的浅拷贝实例。
一只普通的🐏类
- Sheep.java
public class Sheep {
private String name;
private int age;
private String color;
public Sheep(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Sheep [name=" + name + ", age=" + age + ", color=" + color + "]";
}
}克隆🐏的代码示例
- Test.java
public class Test{
public static void main(String[] args) {
// TODO Auto-generated method stub
//传统的方法
Sheep sheep = new Sheep("lbw", 1, "蓝色");
Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
//....
System.out.println(sheep);
System.out.println(sheep2);
System.out.println(sheep3);
System.out.println(sheep4);
System.out.println(sheep5);
//...
}
}- 运行结果
Sheep [name=lbw, age=1, color=蓝色]
Sheep [name=lbw, age=1, color=蓝色]
Sheep [name=lbw, age=1, color=蓝色]
Sheep [name=lbw, age=1, color=蓝色]
Sheep [name=lbw, age=1, color=蓝色]很明显我们复制成功了，但以上的代码是一种浅拷贝的方式进行拷贝。
二、浅拷贝
2.1、概念
浅拷贝字面上意思就是简单浅层次地对对象拷贝，说到这里可能就有人会问了，拷贝对象这玩意还能有深浅？（谁？谁谁？谁问了？）。首先，浅拷贝对拥有引用数据类型属性的对象的拷贝是只能做到对该被拷贝对象的引用数据类型属性的引用地址复制，是不能在堆中创建一个新的属性对象的。
2.2、浅拷贝区别于深拷贝
我们每个对象的属性是可能为引用数据类型（指向堆对象）的，一个对象的某属性中若是引用数据类型就会区别出浅拷贝和深拷贝，浅拷贝对拥有引用数据类型属性的对象的拷贝是只能做到对该被拷贝对象的引用数据类型属性的引用地址复制，是不能在堆中创建一个新的属性对象的。（举个栗子，你去买空调，发现你的钱只能买到一台空调外机和两台内机，这是你只能两个内机共用一个外机，这就好比浅拷贝，拷贝出来的对象只能和被拷贝的对象共用一个属性为引用数据类型指向的堆对象）。
2.3、看图理解
2.4、实例代码
说到浅拷贝就不得不说到经典浅拷贝Object.clone();
还是一只可爱的🐏类，不过该类继承了Cloneable接口，并重写了clone方法，而且有个很重要的点就是该🐏是有朋友的，也就是🐏类是有个属性是引用数据类型的。
- Sheep.java
public class Sheep implements Cloneable {
private String name;
private int age;
private String color;
private String address = "小肥羊";
public Sheep friend; //是对象, 克隆是会如何处理
public Sheep(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
}
//克隆该实例，使用默认的clone方法来完成
@Override
protected Object clone() {
Sheep sheep = null;
try {
sheep = (Sheep)super.clone();
} catch (Exception e) {
// TODO: handle exception
System.out.println(e.getMessage());
}
// TODO Auto-generated method stub
return sheep;
}
}测试类
- Test.java
public class Test{
public static void main(String[] args) {
// System.out.println("原型模式完成对象的创建");
// TODO Auto-generated method stub
Sheep sheep = new Sheep("lbw", 1, "蓝色");
sheep.friend = new Sheep("pdd", 2, "黑色");
Sheep sheep2 = (Sheep)sheep.clone(); //克隆
Sheep sheep3 = (Sheep)sheep.clone(); //克隆
Sheep sheep4 = (Sheep)sheep.clone(); //克隆
Sheep sheep5 = (Sheep)sheep.clone(); //克隆
System.out.println("sheep2 =" + sheep2 + "sheep2.friend=" + sheep2.friend.hashCode());
System.out.println("sheep3 =" + sheep3 + "sheep3.friend=" + sheep3.friend.hashCode());
System.out.println("sheep4 =" + sheep4 + "sheep4.friend=" + sheep4.friend.hashCode());
System.out.println("sheep5 =" + sheep5 + "sheep5.friend=" + sheep5.friend.hashCode());
}
}- 运行结果
sheep2 =Sheep [name=lbw, age=1, color=蓝色, address=小肥羊]sheep2.friend=1173230247
sheep3 =Sheep [name=lbw, age=1, color=蓝色, address=小肥羊]sheep3.friend=1173230247
sheep4 =Sheep [name=lbw, age=1, color=蓝色, address=小肥羊]sheep4.friend=1173230247
sheep5 =Sheep [name=lbw, age=1, color=蓝色, address=小肥羊]sheep5.friend=1173230247细心的朋友可能已经看出来的，通过sheep.friend的hashcode，可以看出我们拷贝出来的🐏对象中的朋友属性中的引用数据类型都是指向同个对象。
三、深拷贝
3.1、概念提出
考虑到我们的业务可能就是需要拷贝出来的对象中每个对象中若是有引用数据类型的属性，那每个引用数据类型属性都是指向一个新的对象的，所以我们提出了深拷贝。
3.2、jvm层面原理理解
浅拷贝只是对每个对象独有的栈内存的数据进行拷贝；深拷贝就是不只是拷贝每个对象的栈内存数据，它也会在堆中给每个引用数据类型的属性都创建新的对象。**
3.3、深拷贝实现方法
深拷贝有以下两种实现方法：
- 第一种是仍然使用clone()方法，但是对引用数据类型的属性做单独处理。
- 第二种是通过反序列化实现。
3.4、实例代码
做为一个其他对象的属性存在的一个对象
- DeepCloneableTarget.java
public class DeepCloneableTarget implements Serializable, Cloneable {
/**
*
*/
private static final long serialVersionUID = 1L;
private String cloneName;
private String cloneClass;
//构造器
public DeepCloneableTarget(String cloneName, String cloneClass) {
this.cloneName = cloneName;
this.cloneClass = cloneClass;
}
//因为该类的属性，都是String , 因此我们这里使用默认的clone完成即可
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}深拷贝对象类，其中包含了两种深拷贝的方法
- DeepProtoType .java
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class DeepProtoType implements Serializable, Cloneable{
public String name; //String 属性
public DeepCloneableTarget deepCloneableTarget;// 引用类型
public DeepProtoType() {
super();
}
//深拷贝 - 方式 1 使用clone 方法
@Override
protected Object clone() throws CloneNotSupportedException {
Object deep = null;
//这里完成对基本数据类型(属性)和String的克隆
deep = super.clone();
//对引用类型的属性，进行单独处理
DeepProtoType deepProtoType = (DeepProtoType)deep;
deepProtoType.deepCloneableTarget = (DeepCloneableTarget)this.deepCloneableTarget.clone();
// TODO Auto-generated method stub
return deepProtoType;
}
//深拷贝 - 方式2 通过对象的序列化实现 (推荐)
public Object deepClone() {
//创建流对象
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
//序列化
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this); //当前这个对象以对象流的方式输出
//反序列化
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
DeepProtoType copyObj = (DeepProtoType)ois.readObject();
return copyObj;
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
return null;
} finally {
//关闭流
try {
bos.close();
oos.close();
bis.close();
ois.close();
} catch (Exception e2) {
// TODO: handle exception
System.out.println(e2.getMessage());
}
}
}
}测试代码
- Test.java
public class Test{
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
DeepProtoType p = new DeepProtoType();
p.name = "卢本伟";
p.deepCloneableTarget = new DeepCloneableTarget("闪电鞭", "浑元功法");
//方式1 完成深拷贝
// DeepProtoType p2 = (DeepProtoType) p.clone();
//
// System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
// System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
//方式2 完成深拷贝
DeepProtoType p2 = (DeepProtoType) p.deepClone();
System.out.println("p.name=" + p.name + " p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
System.out.println("p2.name=" + p.name + " p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
}
}- 运行结果
p.name=卢本伟 p.deepCloneableTarget=1846274136
p2.name=卢本伟 p2.deepCloneableTarget=1725154839不管是第一种是仍然使用clone()方法，但是对引用数据类型的属性做单独处理；还是第二种是通过反序列化实现，得到的结果都是一样的。
可以看到拷贝出来的对象的属性deepCloneableTarget对象的hashcode和被拷贝对象的是不一样的，说明深拷贝成功。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
