这篇文章竟然写了一上午，亲，请怀着感恩的心阅读！！

 

       深拷贝和浅拷贝是经常在面试中会出现的，主要考察你对基本类型和引用类型的理解深度。我在无数次的面试中，应聘者还没有一个人能把这个问题回答情况，包括很多机构的培训老师。这篇文章会让你把基本类型和引用类型的区别搞得清清楚楚，搞清楚这两者的区别，你对任何编程语言的都不怕，因为，这不是js一门语言，是任何编程语言中都需要掌握的知识，而且，在任何编程语言中，两者都是一样的。

 

深拷贝和浅拷贝主要是针对对象的属性是对象（引用类型）

一、基本类型和引用类型的区别

1、先了解内存

   任何编程语言的内存分区几乎都是一样的

 

       内存是存储数据的，不同类型的数据要存储在不同的区域，即分类存放，不同的区域作用和功能也不一样。就像你家里的衣柜一样，也分了不同的区域：如挂西装的区域，放袜子的区域等等，我相信每个人都会把这两个东西放在不同的区域。要不然，当你西装革履地参加一个高档的宴会，手塞在裤兜里，掏出来一只臭袜子，是不是很尴尬！！！哈哈！！！

 

以下为内存的分区图。内存分为四个区域：栈区（堆栈），堆区，全局静态区，只读区（常量区和代码区）。

 

https://blog.csdn.net/jiang7701037/article/details/98728249

 

    2、基本类型和引用类型在内存上存储的区别

现在只看栈区和堆区，不管其它区域，也假定只是局部变量。

​

 

以上函数testf在调用时，

       1）、 定义局部变量 age，由于age是局部变量，所以在栈中申请内存空间，起名为age，又由于给age赋的值250是基本类型，所以，值直接存储在栈中。

       2）、定义局部变量arr，由于arr是局部变量，所以在栈中申请空间，但是arr的内存中存储的是什么？由于给arr赋的值不是基本类型，而是引用类型（new出来的），所以，先在堆中申请空间存放数据 12,23,34,。再把堆区的地址赋给arr。

 

3、到底什么是基本类型和引用类型

      1）、基本类型：就是值类型，即在变量所对应的内存区域存储的是值，如：上面的age变量所对应的内存存储的就是值250.

      2）、引用类型：就是地址类型。

   何为地址：地址就是编号，要地址何用，就是为了容易找到。每个人的家里为什么要有一个唯一的地址，就是在邮寄时，能够找到你家。

比如：我们最早的超市存包的格子，每个格子都有个编号，你存包时，服务员会把你的东西放在某个格子里，再把这个格子的编号给你（一个牌子）。你购物完毕取包时，直接给服务员你的牌子（有编号），服务员根据你的编号就会找到你的包。这个编号就是格子的地址。内存也是一样的，每个内存都有一个编号，方便cpu查找。要不然，浩瀚的内存海洋，cpu要找到数据靠啥找。

以上的变量arr就是引用类型，arr所对应的内存中存储着地址，真正的数据是在地址对应的内存区域里，就像，你填写简历时，会在简历的那张纸上写上你家的地址。简历上写你家地址的地方就相当于arr。而你家是根据这个地址可以找到的。简历上写你家地址的地方就相当于引用着你家（可以想象一根无形的线牵引着你家，在简历上的这根无形的线，顺藤摸瓜就能找到你家）。所以叫做引用类型。

   二、基本类型和引用类型在赋值时内存的变化

你可以认为，赋值就是在拷贝。

1、基本类型：

2、引用类型：

 

如果给arr[0]赋值的话，arr1[0]的值也会发生变化，因为，arr和arr1保存着相同的地址，它门两个引用的数据是共享的。就像你在很多地方（简历的那张纸，户口本上的那张纸）会写上你的家庭地址。这么多张纸都引用着你家。根据一张纸上找到你家，给你家放上一百万的现金(数据改变了，相当于arr[0]=10)，再根据另外一张纸的地址也找到了你家，你发现你一百万在（不要给我说被人拿了）

 

如果在上面的基础上增加一句代码：arr[0]=10;那么内存将会有如下变化：

​​

三、基本类型和引用类型作为函数参数的区别（这个可以不看）

1、基本类型作为函数的参数

2、引用类型作为函数的参数：

四、深拷贝和浅拷贝：

   终于说到了深拷贝和浅拷贝。

其实在第二点已经说到了拷贝，所谓拷贝，就是赋值。把一个变量赋给另外一个变量，就是把变量的内容进行拷贝。把一个对象的值赋给另外一个对象，就是把一个对象拷贝一份。

1、基本类没有问题，

因为，基本类型赋值时，赋的是数据（所以，不存在深拷贝和浅拷贝的问题）。

       如：

    Var x = 100;

    Var y = x; //此时x和y都是100;

   如果要改变y的值，x的值不会改变。

 

2、引用类型有问题

  因为，引用类型赋值时，赋的值地址（就是引用类型变量在内存中保存的内容），强烈建议把前面的第二点（基本类型和引用类型在赋值时内存的变化）多看几遍，以保证理解深刻。这样，一劳永逸，以后在碰到任何跟引用类型有关的话题（如：继承时，父类的属性是引用类型）都没有问题。

      如：

var arr1 = new Array(12,23,34)

Var arr2 = arr1;//这就是一个最简单的浅拷贝

 

如果要改变arr2所引用的数据：arr2[0]=100时，那么arr1[0]的值也是100。

        原因就是 arr1和arr2引用了同一块内存区域（以上的第二点中有体现）。

        

这是最简单的浅拷贝，因为，只是把arr1的地址拷贝的一份给了arr2，并没有把arr1的数据拷贝一份。所以，拷贝的深度不够

         

3、用json对象的方式（也是引用类型）来演示浅拷贝和深拷贝

   

1）、定义一个json对象（对象的属性也是对象）

var p = {
	"id":"007",
	"name":"刘德华",
	"books":new Array("三国演义","红楼梦","水浒传")//这是引用类型
}

 

内存图：

 

2）、把该对象p进行复制一份

• (一)浅拷贝

var p2 = {};
for(let key in p){
	p2[key] = p[key];	
}
p2.books[0] ="四国";
console.log(p2);
console.log(p);

在控制台中打印的结果（p和p2的books[0]都变成了“四国”）：

内存：

 

• (二)深拷贝（初步）

var p2 = {};
for(let key in p){
	if(typeof p[key]=='object'){
		p2[key]=[];//因为,我上面写的是数组,所以,暂时赋值一个空数组.
		for(let i in p[key]){
			p2[key][i] = p[key][i]
		}
	}else{
		p2[key] = p[key];
	}
}
p2.books[0] ="四国";
console.log(p2);
console.log(p);

在控制台中打印的结果（只有p2的books[0]变成了“四国”）

内存：

 

  (三)深拷贝（最终）

3.1、深拷贝_如果属性都是json对象，那么用递归的方式

 

//如果对象的属性是对象(引用类型),属性的属性也是引用类型,即层层嵌套很多.怎么办,只能递归

//如下对象,要复制:

var p = {
	"id":"007",
	"name":"刘德华",
	"wife":{
		"id":"008",
		"name":"刘德的妻子",
		"address":{
			"city":"北京",
			"area":"海淀区"
		}
	}
}

//写函数
function copyObj(obj){
	let newObj={};
	for(let key in obj){
		if(typeof obj[key] =='object'){//如:key是wife,引用类型,那就递归
			newObj[key] = copyObj(obj[key])
		}else{//基本类型,直接赋值
			newObj[key] = obj[key];
		}
	}
	return newObj;
}

let pNew = copyObj(p);
pNew.wife.name="张三疯";
pNew.wife.address.city = "香港";
console.log(pNew);
console.log(p);

 

3.2、深拷贝_如果属性是数组等非键值对的对象

      就得单独处理：要么给数组增加一个自我复制的函数（建议这样做），要么单独判断。

//给数组对象增加一个方法，用来复制自己
Array.prototype.copyself = function(){
	let arr = new Array();
	for(let i in this){
		arr[i]  = this[i]
	}
	return arr;
}

var p = {
	"id":"007",
	"name":"刘德华",
	"books":new Array("三国演义","红楼梦","水浒传")//这是引用类型
}

function copyObj(obj){
	let newObj={};
	for(let key in obj){
		if(typeof obj[key] =='object'){//如:key是wife,引用类型,那就递归
			newObj[key] = obj[key].copyself();
		}else{//基本类型,直接赋值
			newObj[key] = obj[key];
		}
	}
	return newObj;
}

var pNew = copyObj(p);
pNew.books[0] = "四国";
console.log(pNew);
console.log(p);  

这篇文章竟然写了一上午，亲，请怀着感恩的心阅读

首先，明确一点深拷贝和浅拷贝是针对对象属性为对象的，因为基本数据类型在进行赋值操作时（也就是拷贝）是直接将值赋给了新的变量，也就是该变量是原变量的一个副本，这个时候你修改两者中的任何一个的值都不会影响另一个，而对于对象或者引用数据来说在进行浅拷贝时，只是将对象的引用复制了一份，也就内存地址，即两个不同的变量指向了同一个内存地址，那么在改变任一个变量的值都是该变这个内存地址的所存储的值，所以两个变量的值都会改变。

一、clone()方法

在Java中是用clone()方法实现深拷贝的，比如以下代码在Java中是很常见的

Person p = new Person(23, "zhang");
		Person p1 = p;
		
		System.out.println(p);
		System.out.println(p1);

这段代码的打印结果为：

testclone.Person@2f9ee1ac
testclone.Person@2f9ee1ac 

可以看出两者打印的地址是相同的，既然地址相同那就代表两者是同一个对象，而p和p1都只是引用罢了。代码执行后，内存中的情况

 

而下面这段代码才是真的克隆了一个对象

Person p = new Person(23, "zhang");
		Person p1 = (Person) p.clone();
		
		System.out.println(p);
		System.out.println(p1)

打印的结果为：

testclone.Person@2f9ee1ac
testclone.Person@67f1fba0

从结果来看两者不是同一个地址，那自然就不是同一个对象，而内存情况如下

 二、深拷贝和浅拷贝

在上面的代码中Person中有两个成员变量，分别是name和age， name是String类型， age是int类型。代码非常简单，如下所示：

public class Person implements Cloneable{
	
	private int age ;
	private String name;
	
	public Person(int age, String name) {
		this.age = age;
		this.name = name;
	}
	
	public Person() {}
 
	public int getAge() {
		return age;
	}
 
	public String getName() {
		return name;
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return (Person)super.clone();
	}
}

 Person类的两个成员变量中，age是基本数据类型，关于基本数据类型的拷贝在上面就已经说过了，但是name是引用数据类型，它只是一个引用， 指向一个真正的String对象，那么对它的拷贝有两种方式： 直接将源对象中的name的引用值拷贝给新对象的name字段， 或者是根据原Person对象中的name指向的字符串对象创建一个新的相同的字符串对象，将这个新字符串对象的引用赋给新拷贝的Person对象的name字段。这两种拷贝方式分别叫做浅拷贝和深拷贝。深拷贝和浅拷贝的原理如下图所示：

下面我们通过代码来验证：如果两个Person对象的name的地址值相同， 说明两个对象的name都指向同一个String对象， 也就是浅拷贝， 而如果两个对象的name的地址值不同， 那么就说明指向不同的String对象， 也就是在拷贝Person对象的时候， 同时拷贝了name引用的String对象， 也就是深拷贝。验证代码如下：

Person p = new Person(23, "zhang");
		Person p1 = (Person) p.clone();
		
		String result = p.getName() == p1.getName() 
				? "clone是浅拷贝的" : "clone是深拷贝的";
		
		System.out.println(result);

打印的结果为：

clone是浅拷贝

也就是clone方法本身是一个浅拷贝的方法，而上一个代码我们又得出clone是深拷贝，那么是我前面写错了吗？那当然不是，clone方法本身是浅拷贝的，但是我们可以通过重写该方法来实现深拷贝 ，所以要实现深拷贝我们就需要实现Cloneable接口，覆盖并实现clone方法，除了调用父类中的clone方法得到新的对象， 还要将该类中的引用变量也clone出来。如果只是用Object中默认的clone方法，是浅拷贝的，再次以下面的代码验证：

static class Body implements Cloneable{
		public Head head;
		
		public Body() {}
 
		public Body(Head head) {this.head = head;}
 
		@Override
		protected Object clone() throws CloneNotSupportedException {
			return super.clone();
		}
		
	}
	static class Head /*implements Cloneable*/{
		public  Face face;
		
		public Head() {}
		public Head(Face face){this.face = face;}
		
	} 
	public static void main(String[] args) throws CloneNotSupportedException {
		
		Body body = new Body(new Head());
		
		Body body1 = (Body) body.clone();
		
		System.out.println("body == body1 : " + (body == body1) );
		
		System.out.println("body.head == body1.head : " +  (body.head == body1.head));
		
		
	}

 在上述代码中有两个主要的类，Body和Face，Body类中又组合了Face对象，在对Body进行clone时，它所组合的Face对象时浅拷贝，其打印结果可以很好的证明这一点：

body == body1 : false
body.head == body1.head : true

如果要使Body对象在clone时进行深拷贝， 那么就要在Body的clone方法中，将源对象引用的Head对象也clone一份。

static class Body implements Cloneable{
		public Head head;
		public Body() {}
		public Body(Head head) {this.head = head;}
 
		@Override
		protected Object clone() throws CloneNotSupportedException {
			Body newBody =  (Body) super.clone();
			newBody.head = (Head) head.clone();
			return newBody;
		}
		
	}
	static class Head implements Cloneable{
		public  Face face;
		
		public Head() {}
		public Head(Face face){this.face = face;}
		@Override
		protected Object clone() throws CloneNotSupportedException {
			return super.clone();
		}
	} 
	public static void main(String[] args) throws CloneNotSupportedException {
		
		Body body = new Body(new Head());
		
		Body body1 = (Body) body.clone();
		
		System.out.println("body == body1 : " + (body == body1) );
		
		System.out.println("body.head == body1.head : " +  (body.head == body1.head));
		
		
	}

 

打印结果为：
body == body1 : false
body.head == body1.head : false

由此可见， body和body1内的head引用指向了不同的Head对象， 也就是说在clone Body对象的同时， 也拷贝了它所引用的Head对象， 进行了深拷贝。
从以上的内容中我们可以知道，一个对象要实现深拷贝，就要实现Cloneable接口，重写clone（）方法，并在clone（）方法中将对象引用的其他对象也要clone一份，这就要求被引用的对象也要实现Cloneable接口，并实现clone（）方法。

而按照这个结论，Body类中组合了Head类，而Head类中又组合了Face类，在对Body对象进行深拷贝时，会拷贝其中的Head类，而这时默认执行的时浅拷贝，也就是说其中的Face对象并不会被拷贝，代码如下：

static class Body implements Cloneable{
		public Head head;
		public Body() {}
		public Body(Head head) {this.head = head;}
 
		@Override
		protected Object clone() throws CloneNotSupportedException {
			Body newBody =  (Body) super.clone();
			newBody.head = (Head) head.clone();
			return newBody;
		}
		
	}
	
	static class Head implements Cloneable{
		public  Face face;
		
		public Head() {}
		public Head(Face face){this.face = face;}
		@Override
		protected Object clone() throws CloneNotSupportedException {
			return super.clone();
		}
	} 
	
	static class Face{}
	
	public static void main(String[] args) throws CloneNotSupportedException {
		
		Body body = new Body(new Head(new Face()));
		
		Body body1 = (Body) body.clone();
		
		System.out.println("body == body1 : " + (body == body1) );
		
		System.out.println("body.head == body1.head : " +  (body.head == body1.head));
		
		System.out.println("body.head.face == body1.head.face : " +  (body.head.face == body1.head.face));
		
		
	}

打印结果为：

body == body1 : false
body.head == body1.head : false
body.head.face == body1.head.face : true

 

那我们可以想一想，这对Body对象来说，到底是不是深拷贝，其实是可以算的，因为Body对象中的引用对象是拷贝了的（这段代码中只有Head对象的引用），也就是说两个独立的Body对象中的Head引用指向了两个独立的Head对象，但对于Head对象来说，其Face引用指向了同一个Face对象。所以严格来说这是一种不彻底的深拷贝，而若是想要彻底的深拷贝，就要保证该对象的所有引用对象的类型都要去实现Cloneable接口，实现clone方法。 

参考文献：https://blog.csdn.net/zhangjg_blog/article/details/18369201