Java中的clone() 深拷贝 浅拷贝

上图展示了浅拷贝：对于非基本数据类型，clone过后，结果两个指针指向了同一块儿内存空间，所以仅仅是浅拷贝，这样的话如果对一个对象进行操作，另一个内容也会变，这显然是不合理的，应该每个对象分别保存自己的数据。

所以我们要进行深拷贝！

浅拷贝和深拷贝例子：

[java] view plaincopy

1. import java.util.Vector;
3. public class Student implements Cloneable{
4. private int id;
5. private String name;
6. private Vector courses;
8. public Student(){
9. try{
10. Thread.sleep(1000);
11. System.out.println("Student Construnctor called");
12. }catch(InterruptedException e){
13. e.printStackTrace();
14. }
15. }
17. public int getId(){
18. return id;
19. }
20. public void setId(int id){
21. this.id=id;
22. }
23. public String getName(){
24. return name;
25. }
26. public void setName(String name){
27. this.name=name;
28. }
29. public Vector getCourses(){
30. return courses;
31. }
32. public void setCourses(Vector courses){
33. this.courses=courses;
34. }
36. public Student newInstance(){ //使用clone()创建对象，浅拷贝
37. try{
38. return (Student)this.clone();
39. }catch(CloneNotSupportedException e){
40. e.printStackTrace();
41. }
42. return null;
43. }
45. public Student deepClone(){ //使用clone()创建对象，深拷贝
46. try{
47. Student cloning = (Student) super.clone();
48. // Student cloning = (Strdent) this.clone(); //和上一句话效果等价
49. cloning.courses = new Vector(); //关键点：非基本数据类型的空间需要自己新开辟一块儿
50. return cloning;
51. }catch(CloneNotSupportedException e){
52. e.printStackTrace();
53. }
54. return null;
55. }
57. }

[java] view plaincopy

1. import java.util.Vector;
4. public class Test {
6. public static void main(String[] args) {
7. // TODO Auto-generated method stub
8. Student stu1 = null;
10. shallowCopyDemo(stu1);
11. System.out.println("----- ----- -----I'm cut-off rule----- ----- -----");
12. deepCopyDemo(stu1);
14. }
16. public static void shallowCopyDemo(Student stu1) {
17. stu1=new Student();
18. Vector cs=new Vector();
19. cs.add("Java");
20. stu1.setId(1);
21. stu1.setName("Tom");
22. stu1.setCourses(cs);
24. Student stu2=stu1.newInstance();
25. stu2.setId(2);
26. stu2.setName("Mary");
27. stu2.getCourses().add("C#");
29. System.out.println("stu1'name:"+stu1.getName());
30. System.out.println("stu2'name:"+stu2.getName());
31. System.out.println(stu1.getCourses()==stu2.getCourses());
32. System.out.println(stu1.getName + "'s course: " + stu1.getCourses());
33. System.out.println(stu2.getName + "'s course: " + stu2.getCourses());
34. }
36. public static void deepCopyDemo(Student stu1) {
37. stu1=new Student();
38. Vector cs=new Vector();
39. cs.add("Java");
40. stu1.setId(1);
41. stu1.setName("Tom");
42. stu1.setCourses(cs);
44. Student stu2=stu1.deepClone();
45. stu2.setId(2);
46. stu2.setName("Mary");
47. stu2.getCourses().add("C#");
49. System.out.println("stu1'name:"+stu1.getName());
50. System.out.println("stu2'name:"+stu2.getName());
51. System.out.println(stu1.getCourses()==stu2.getCourses());
52. System.out.println(stu1.getName + "'s course: " + stu1.getCourses());
53. System.out.println(stu2.getName + "'s course: " + stu2.getCourses());
54. }
56. }

输出结果：

Student Construnctor called stu1'name:Tom stu2'name:Mary true Tom's course: [Java, C#] Mary's course: [Java, C#] ----- ----- -----I'm cut-off rule----- ----- ----- Student Construnctor called stu1'name:Tom stu2'name:Mary false Tom's course: [Java] Mary's course: [C#]

由结果可知，第一种调用浅拷贝导致对Mary添加课程C#的时候，Tom的课程中竟然 也有了C#，而且Mary的课程中也有Tom的Java，且stu1.getCourses()==stu2.getCourses()返回的是 “true”，说明二者的course属性指向的就是同一块儿内存；而在第二种情况中，我们为copy出来的Mary的course新开辟了一块儿空间 cloning.courses = new Vector()，所以Tom和Mary操控的是不同的Vector内存，两者自然就不一样了。

在上例中，深拷贝deepClone()和浅拷贝newInstance()函数都是 我们自己写的，所以deepClone()的Student cloning = (Student) super.clone()和Student cloning = (Strdent) this.clone()都是可行的。除此之外，我们也可以直接覆写本类的clone()函数这样的话就只能使用Student cloning = (Student) super.clone()了，覆写的代码如下：

[java] view plaincopy

1. public Object clone(){ //覆写clone()，深拷贝
2. try{
3. Student cloning = (Student) super.clone();
4. cloning.courses = new Vector(); //关键点：非基本数据类型的空间需要自己新开辟一块儿
5. return cloning;
6. }catch(CloneNotSupportedException e){
7. e.printStackTrace();
8. }
9. return null;
10. }

这里不能使用Student cloning = (Strdent) this.clone()的原因是我们正在覆写本类的clone()方法，如果再调用本类的函数，即：this.clone()，就相当于无线递归无限死循环了，最终肯定会崩溃的。所以这里我们只能调用父类的函数，即：super.clone()。

所以，要么自己给自己的深拷贝函数起一个名字，要么覆写本类的clone()方法，自己选一个就好，但两者的关键都在于——对于非基本数据类型，要重新new一块儿空间。