一、基本数据类型 & 引用类型
1.1 基本概念
在讨论 浅拷贝 & 深拷贝 这个问题之前，我们需要先了解 基本数据类型 & 引用类型 这两者之间的区别，否则后面会很疑惑。在Java当中，这两类的代表分别为：
- 八种 基本数据类型：
byte、short、int、long、float、double、char、boolean。 - 引用类型：除去基本数据类型的其它类型都是引用数据类型，例如类、接口、数组。
在 (1) JAVA 基本数据类型与引用数据类型 一文中总结了这两者的区别：
| 基本数据类型 | 引用数据类型 |
|---|---|
| 变量名指向具体的数值 | 变量名指向存数据对象的内存地址，即变量名指向hash值 |
| 变量在声明之后就会立刻分配给他内存空间 | 它以特殊的方式指向对象实体，这类变量声明时不会分配内存，只是存储了一个内存地址 |
| 基本类型之间的赋值是创建新的拷贝 | 对象之间的赋值只是传递引用 |
| “==”和“!=”是在比较值 | “==”和“!=”是在比较两个引用是否相同 |
使用时需要赋具体值，判断时使用==号 |
使用时可以赋值null，判断时使用equals方法 |
1.2 基本数据类型 和 引用数据类型 传递区别
程序设计语言中有关参数传递给方法的两个专业术语是：
- 按值调用：表示方法接收的是调用者提供的值。
- 按引用调用：表示方法接收的是调用者提供的变量的地址。
在Java中 不存在按引用调用，也就是说，假如方法传递的是一个引用数据类型，那么可以修改 引用所指向的对象的属性，但不能 让引用指向其它的对象。
1.2.1 传递基本数据类型
public static void methodBasic() {
int lNum = 3;
methodRunInner(lNum);
Log.d("CopySample", "After methodRunInner, lNum=" + lNum);
}
private static void methodRunInner(int lNum) {
lNum++;
Log.d("CopySample", "methodRunInner, lNum=" + lNum);
}
传递基本数据类型
1.2.2 传递引用数据类型
当传递的是引用数据类型，可以在函数中修改该引用所指向的对象的成员变量的值，如下所示：
public static void methodRef() {
NumHolder holder = new NumHolder();
holder.num = 3;
methodRunInner(holder);
Log.d("CopySample", "After methodRunInner, holder.num=" + holder.num);
}
private static void methodRunInner(NumHolder holder) {
holder.num++;
Log.d("CopySample", "methodRunInner, holder.num=" + holder.num);
}
private static class NumHolder {
int num;
}
传递引用数据类型
但是，我们并不能让引用指向其它的对象，例子如下所示：
public static void methodSwapRef() {
NumHolder lHolder = new NumHolder();
NumHolder rHolder = new NumHolder();
lHolder.num = 3;
rHolder.num = 4;
methodRunInner(lHolder, rHolder);
Log.d("CopySample", "methodSwapRef, lHolder.num=" + lHolder.num + ", rHolder.num=" + rHolder.num);
}
private static void methodRunInner(NumHolder lHolder, NumHolder rHolder) {
NumHolder temp = lHolder;
lHolder = rHolder;
rHolder = temp;
Log.d("CopySample", "methodRunInner, lHolder.num=" + lHolder.num + ", rHolder.num=" + rHolder.num);
}
private static class NumHolder {
int num;
}
在方法中交换引用
二、浅拷贝 Vs 深拷贝
在对基本数据类型和引用数据类型了解之后，我们就可以开始分析浅拷贝 & 深拷贝了。
2.1 定义
首先让我们来看一下它们俩的定义：
- 浅拷贝：使用一个已知实例对新创建实例的成员变量逐个 赋值，这个方式被称为浅拷贝。
- 深拷贝：当一个类的拷贝构造方法，不仅要复制对象的所有非引用成员变量值，还要为引用类型的成员变量创建新的实例，并且初始化为形式参数实例值。
2.2 赋值操作符 =
上面我们讲到了一个关键词 - 赋值，那么让我们来先看一下赋值操作符=在基本数据类型和引用数据类型上会发生什么。
2.2.1 基本数据类型
public static void startRun1() {
int lNumber = 2;
int rNumber = lNumber;
rNumber = 3;
Log.d("CopySample", "lNumber=" + lNumber + ",rNumber=" + rNumber);
}
运行结果为：
基本数据类型 - 赋值结果
对于基本数据类型，当我们用
rNumber对
lNumber进行赋值的时候，实际上是开辟了一块新的内存空间，因此对于
rNumber的改变，并不会影响
lNumber。
2.2.2 引用数据类型
public static void startRun2() {
People lPeople = new People();
lPeople.age = 10;
People rPeople = lPeople;
rPeople.age = 20;
Log.d("CopySample", "lPeople=" + lPeople + ",lPeople.age=" + lPeople.age + ",\n" +
"rPeople=" + rPeople + ",rPeople.age=" + rPeople.age);
}
public static class People {
int age;
}
引用数据类型 - 赋值结果
对于引用数据类型，它们的内容其实是内存的地址。因此使用赋值操作符
=后，
lPeople和
rPeople指向同一块内存地址（即上图中的
@f7a53fd），通过该地址我们可以访问到它存储的对象。
所以，当我们通过rPeople来改变成员变量age的值之后，通过lPeople访问该成员变量可以看到更新后的值，这就是 基本数据类型和引用数据类型赋值的区别。
2.3 浅拷贝
浅拷贝的前提是该类了实现Cloneable接口，并重写clone方法。在拷贝某个对象时，调用该对象的clone方法返回一个新的对象，该对象就是浅拷贝的结果。
public static void startRun3() {
People lPeople = new People();
lPeople.age = 10;
lPeople.holder = new People.Holder();
lPeople.holder.holderValue = 10;
People rPeople = (People) lPeople.clone();
rPeople.age = 20;
rPeople.holder.holderValue = 20;
Log.d("CopySample", "lPeople=" + lPeople + ",lPeople.age=" + lPeople.age + ",lPeople.holder=" + lPeople.holder + ",\n" +
"rPeople=" + rPeople + ",rPeople.age=" + rPeople.age + ",rPeople.holder=" + rPeople.holder);
Log.d("CopySample", "lHolderValue=" + lPeople.holder.holderValue + ",rHolderValue=" + rPeople.holder.holderValue);
}
public static class People implements Cloneable {
int age;
Holder holder;
@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public static class Holder {
int holderValue;
}
}
浅拷贝
从上面的代码当中，我们可以看到，浅拷贝与赋值的区别在于：浅拷贝会为拷贝的对象 开辟一块新的内存空间（被拷贝的对象在
@f7a53fd，拷贝的对象在
@3a8bb43），但是这并不意味着这两者之间一定是完全独立的，因为
clone方法的默认实现，对类中不同类型的成员变量会有不同的表现。
- 基本数据类型：对该成员变量进行复制。
- 引用数据类型：复制引用，但不会开辟新的内存空间，因此被拷贝对象的该成员变量与拷贝对象对应的成员变量 指向同一块内存地址（上图中的
@f5b08f2），就和我们在2.2.2中看到的一样。
正是由于这一区别，当我们通过rPeople对其成员变量进行修改时，lPeople的age属性（基本数据类型）不受影响，而holder.holderValue（引用数据类型）却会跟着改变。
2.4 深拷贝
下面，我们先来演示如何对2.2中的例子进行改进，实现深拷贝。我们让Holder类也实现了Clonable接口，因此调用它的clone方法后会返回一个新对象的引用；之后，还要重写People的clone方法，对clone之后的对象中的成员变量holder采用clone方法进行拷贝。
public static void startRun3() {
People lPeople = new People();
lPeople.age = 10;
lPeople.holder = new People.Holder();
lPeople.holder.holderValue = 10;
People rPeople = (People) lPeople.clone();
rPeople.age = 20;
rPeople.holder.holderValue = 20;
Log.d("CopySample", "lPeople=" + lPeople + ",lPeople.age=" + lPeople.age + ",lPeople.holder=" + lPeople.holder + ",\n" +
"rPeople=" + rPeople + ",rPeople.age=" + rPeople.age + ",rPeople.holder=" + rPeople.holder);
Log.d("CopySample", "lHolderValue=" + lPeople.holder.holderValue + ",rHolderValue=" + rPeople.holder.holderValue);
}
public static class People implements Cloneable {
int age;
Holder holder;
@Override
protected Object clone() {
try {
People people = (People) super.clone();
people.holder = (People.Holder) this.holder.clone();
return people;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public static class Holder implements Cloneable {
int holderValue;
@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
}
深拷贝
从打印的结果可以看到
rPeople的
holder引用指向了一块新的内存地址
@b855c0，因此对它的
holderValue进行改变并不会影响到
lPeople的
holder变量中的
holderValue。
三、数组 & 集合的拷贝
3.1 数组的拷贝
数组除了默认实现了clone()方法之外，还提供了Arrays.copyOf方法用于拷贝，这两者都是浅拷贝。
3.1.1 基本数据类型数组
public static void startRun4() {
int[] lNumbers1 = new int[5];
int[] rNumbers1 = lNumbers1;
rNumbers1[0] = 1;
Log.d("CopySample", "lNumbers1[0]=" + lNumbers1[0] + ",rNumbers1[0]=" + rNumbers1[0]);
int[] lNumbers2 = new int[5];
int[] rNumbers2 = Arrays.copyOf(lNumbers2, lNumbers2.length);
rNumbers2[0] = 1;
Log.d("CopySample", "lNumbers2[0]=" + lNumbers2[0] + ",rNumbers2[0]=" + rNumbers2[0]);
int[] lNumbers3 = new int[5];
int[] rNumbers3 = lNumbers3.clone();
rNumbers3[0] = 1;
Log.d("CopySample", "lNumbers3[0]=" + lNumbers3[0] + ",rNumbers3[0]=" + rNumbers3[0]);
}
运行结果：
基本数据类型数组
3.1.2 引用数据类型数组
public static void startRun5() {
People[] lNumbers1 = new People[5];
lNumbers1[0] = new People();
People[] rNumbers1 = lNumbers1;
Log.d("CopySample", "lNumbers1[0]=" + lNumbers1[0] + ",rNumbers1[0]=" + rNumbers1[0]);
People[] lNumbers2 = new People[5];
lNumbers2[0] = new People();
People[] rNumbers2 = Arrays.copyOf(lNumbers2, lNumbers2.length);
Log.d("CopySample", "lNumbers2[0]=" + lNumbers2[0] + ",rNumbers2[0]=" + rNumbers2[0]);
People[] lNumbers3 = new People[5];
lNumbers3[0] = new People();
People[] rNumbers3 = lNumbers3.clone();
Log.d("CopySample", "lNumbers3[0]=" + lNumbers3[0] + ",rNumbers3[0]=" + rNumbers3[0]);
}
public static class People implements Cloneable {
int age;
Holder holder;
@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public static class Holder {
int holderValue;
}
}
引用数据类型数组
3.2 集合的拷贝
集合的拷贝也是我们平时经常会遇到的，一般情况下，我们都是用浅拷贝来实现，即通过构造函数或者clone方法。
3.2.1 构造函数和 clone() 默认都是浅拷贝
public static void listShallowRun() {
ArrayList lPeoples = new ArrayList<>();
People people1 = new People();
lPeoples.add(people1);
Log.d("CopySample", "listShallowRun, lPeoples[0]=" + lPeoples.get(0));
ArrayList rPeoples = (ArrayList) lPeoples.clone();
Log.d("CopySample", "listShallowRun, rPeoples[0]=" + rPeoples.get(0));
}
public static class People implements Cloneable {
int age;
Holder holder;
@Override
protected Object clone() {
try {
People people = (People) super.clone();
people.holder = (People.Holder) this.holder.clone();
return people;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public static class Holder implements Cloneable {
int holderValue;
@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
}
集合的浅拷贝
3.2.2 实现集合的深拷贝
在某些特殊情况下，如果需要实现集合的深拷贝，那就要创建一个新的集合，然后通过深拷贝原先集合中的每个元素，将这些元素加入到新的集合当中。
public static void listDeepRun() {
ArrayList lPeoples = new ArrayList<>();
People people1 = new People();
people1.holder = new People.Holder();
lPeoples.add(people1);
Log.d("CopySample", "listShallowRun, lPeoples[0]=" + lPeoples.get(0));
ArrayList rPeoples = new ArrayList<>();
for (People people : lPeoples) {
rPeoples.add((People) people.clone());
}
Log.d("CopySample", "listShallowRun, rPeoples[0]=" + rPeoples.get(0));
}
public static class People implements Cloneable {
int age;
Holder holder;
@Override
protected Object clone() {
try {
People people = (People) super.clone();
people.holder = (People.Holder) this.holder.clone();
return people;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public static class Holder implements Cloneable {
int holderValue;
@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
}
采用 clone 实现集合的深拷贝
四、参考文献
(1) Java 基本数据类型与引用数据类型
(2) Java 基本数据类型传递与引用传递区别详解
(3) 详解 Java 中的 clone 方法 -- 原型模式
(4) Java List 复制：浅拷贝与深拷贝
(5) 渐析 Java 的浅拷贝和深拷贝
更多文章，欢迎访问我的 Android 知识梳理系列：
- Android 知识梳理目录：http://www.jianshu.com/p/fd82d18994ce
- Android 面试文档分享：http://www.jianshu.com/p/8456fe6b27c4