Java中的深拷贝和浅拷贝

1．浅拷贝与深拷贝概念

(1)浅拷贝（浅克隆）

 浅拷贝又叫浅复制，将对象中的所有字段复制到新的对象（副本）中。其中，值类型字段(java中8中原始类型)的值被复制到副本中后，在副本中的修改不会影响到源对象对应的值。而引用类型的字段被复制到副本中的还是引用类型的引用，而不是引用的对象，在副本中对引用类型的字段值做修改会影响到源对象本身。

浅拷贝简单归纳就是只复制一个对象，对象内部存在指向其他对象，数组或引用则不复制。

(2)深拷贝（深克隆）

 将对象中的所有字段复制到新的对象中。不过，无论是对象的值类型字段，还是引用类型字段，都会被重新创建并赋值，对于副本的修改，不会影响到源对象本身。

深拷贝简单归纳就是对象内部引用的对象均复制。

2．Java中的clone()方法

(1)clone()方法将对象复制了一份并返回给调用者。一般而言，clone()方法满足下面规范：

①对任何的对象x，都有x.clone() != x;//克隆对象与原对象不是同一个对象

②对任何的对象x，都有x.clone().getClass()== x.getClass();//克隆对象与原对象的类型一样

③如果对象x的equals()方法定义恰当，那么x.clone().equals(x);应该成立。

(2)Java中对象的克隆

clone()方法是在Object中定义的,而且是protected的，只有实现了Cloneable接口的类才可以在其实例上调用clone()方法，否则会抛出CloneNotSupportException。

为了获取对象的一份拷贝，我们可以利用Object类的clone()方法，也可以实现Cloneable接口，覆盖基类的clone()方法，在clone()方法中，调用super.clone()。

Cloneable接口是一个标记接口,也就是没有任何内容,定义如下:
package java.lang;
pubilc interface Cloneable{
}

 例子代码如下：

[java]  view plain  copy

1. class Student implements Cloneable  
2. {  
3.     String name;  
4.     int age;  
5.     Student(String name,int age){  
6.         this.name=name;  
7.         this.age=age;  
8.     }  
9.     public Object clone(){  
10.         Object o=null;  
11.         try{  
12.         //Object中的clone()识别出你要复制的是哪一个对象  
13.                 o=(Student)super.clone();  
14.         }catch(CloneNotSupportedException e){  
15.             System.out.println(e.toString());  
16.         }  
17.         return o;  
18.     }  
19. }  
20.  public static void main(String[] args){  
21.         Student s1=new Student("zhangsan",18);  
22.         Student s2=(Student)s1.clone();  
23.         s2.name="lisi";  
24.         s2.age=20;  
25. System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后，不影响学生1的值。  
26.    }  

说明：

①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？

在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。

②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明：

[java]  view plain  copy

1. //Professor没有实现Cloneable接口，默认使用java.lang.Object类的clone()方法  
2. class Professor{  
3.     String name;  
4.     int age;  
5.     Professor(String name,int age){  
6.         this.name=name;  
7.         this.age=age;  
8.     }  
9. }  
10. //Student实现了Cloneable接口  
11. class Student implements Cloneable{  
12.     String name;//常量对象。  
13.     int age;  
14.     Professor p;  
15.     Student(String name,int age,Professor p){  
16.         this.name=name;  
17.         this.age=age;  
18.         this.p=p;  
19.     }  
20.     public Object clone(){  
21.         Student o=null;  
22.         try{  
23.             o=(Student)super.clone();  
24.         }catch(CloneNotSupportedException e){  
25.             System.out.println(e.toString());  
26.         }  
27.     //使用Object类的clone()方法  
28.         o.p=(Professor)this.p.clone();  
29.         return o;  
30.     }  
31. }  
32. public static void main(String[] args){  
33.       Professor p=new Professor("wangwu",50);  
34.       Student s1=new Student("zhangsan",18,p);  
35.       Student s2=(Student)s1.clone();  
36.       s2.p.name="lisi";  
37.       s2.p.age=30;  
38.    //学生1的教授也变成了lisi,age为30  
39.    System.out.println("name="+s1.p.name+","+"age="+s1.p.age);   
40. }  

那应该如何实现深层次的克隆，即修改s2的教授不会影响s1的教授？代码改进如下：

[java]  view plain  copy

1. //Professor类实现了Cloneable接口，不再使用Object默认的clone()方法  
2. class Professor implements Cloneable{  
3.     String name;  
4.     int age;  
5.     Professor(String name,int age){  
6.         this.name=name;  
7.         this.age=age;  
8.     }  
9.     public Object clone(){  
10.         Object o=null;  
11.         try{  
12.             o=super.clone();  
13.         }catch(CloneNotSupportedException e){  
14.             System.out.println(e.toString());  
15.         }  
16.         return o;  
17.     }  
18. }  
19. class Student implements Cloneable{  
20.     String name;  
21.     int age;  
22.     Professor p;  
23.     Student(String name,int age,Professor p){  
24.         this.name=name;  
25.         this.age=age;  
26.         this.p=p;  
27.     }  
28.     public Object clone(){  
29.         Student o=null;  
30.         try{  
31.             o=(Student)super.clone();  
32.         }catch(CloneNotSupportedException e){  
33.             System.out.println(e.toString());  
34.         }  
35.     //调用Professor类的clone()方法实现深拷贝  
36.         o.p=(Professor)this.p.clone();  
37.         return o;  
38.     }  
39. }  
40. public static void main(String[] args){  
41.       Professor p=new Professor("wangwu",50);  
42.       Student s1=new Student("zhangsan",18,p);  
43.       Student s2=(Student)s1.clone();  
44.       s2.p.name="lisi";  
45.      s2.p.age=30;  
46.    //学生1的教授不改变  
47.    System.out.println("name="+s1.p.name+","+"age="+s1.p.age);  
48. }  

3．利用串行化来做深复制

把对象写到流里的过程是串行化（Serilization）过程，又叫对象序列化，而把对象从流中读出来的（Deserialization）过程叫反序列化。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来便可以重建对象。

如下为深复制源代码：

[java]  view plain  copy

1. public Object deepClone(){  
2.     //将对象写到流里  
3.     ByteArrayOutoutStream bo=new ByteArrayOutputStream();  
4.     ObjectOutputStream oo=new ObjectOutputStream(bo);  
5.     oo.writeObject(this);  
6.     //从流里读出来  
7. ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());  
8.     ObjectInputStream oi=new ObjectInputStream(bi);  
9.     return(oi.readObject());  
10. }  
11. 这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。  
12. class Professor implements Serializable{  
13.     String name;  
14.     int age;  
15.     Professor(String name,int age){  
16.         this.name=name;  
17.         this.age=age;  
18.     }  
19. }  
20. class Student implements Serializable{  
21.     String name;  
22.     int age;  
23.     Professor p;  
24.     Student(String name,int age,Professor p){  
25.         this.name=name;  
26.         this.age=age;  
27.         this.p=p;  
28.     }  
29.     public Object deepClone() throws IOException,OptionalDataException,ClassNotFoundException{  
30.     //将对象写到流里  
31.     ByteArrayOutputStream bo=new ByteArrayOutputStream();  
32.     ObjectOutputStream oo=new ObjectOutputStream(bo);  
33.     oo.writeObject(this);// object of studnet  
34.  /  /从流里读出来  
35.     ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());  
36.     ObjectInputStream oi=new ObjectInputStream(bi);  
37.     return(oi.readObject());  
38. }   
39. public static void main(String[] args){  
40.       Professor p=new Professor("wangwu",50);  
41.       Student s1=new Student("zhangsan",18,p);  
42.       Student s2=(Student)s1.deepClone();  
43.       s2.p.name="lisi";  
44.       s2.p.age=30;  
45.    //学生1的教授不改变  
46.    System.out.println("name="+s1.p.name+","+"age="+s1.p.age);   
47. }  
48. }  

转载自： http://blog.csdn.net/chjttony/article/details/7477346

参考：http://blog.csdn.net/u014727260/article/details/55003402

 浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。

 深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

 现在为了要在clone对象时进行深拷贝， 那么就要Clonable接口，覆盖并实现clone方法，除了调用父类中的clone方法得到新的对象， 还要将该类中的引用变量也clone出来。如果只是用Object中默认的clone方法，是浅拷贝的。