java序列化实现深拷贝_Java 深拷贝和浅拷贝 利用序列化实现深拷贝

Java 深拷贝和浅拷贝

转自：http://www.cnblogs.com/mengdd/archive/2013/02/20/2917971.html

深拷贝(deep clone)与浅拷贝(shallow clone)

浅拷贝(浅复制、浅克隆)：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。

换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

深拷贝(深复制、深克隆)：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。

那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。

换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

Java中对象的克隆

1.为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。

2.在派生类中覆盖基类的clone()方法，并声明为public。

(Object类中的clone()方法是protected的)。

在子类重写的时候，可以扩大访问修饰符的范围。

3.在派生类的clone()方法中，调用super.clone()。

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

4.在派生类中实现Cloneable接口。

这个接口中没有什么方法，只是说明作用。

注意：继承自java.lang.Object类的clone()方法是浅复制。

Java的clone()方法

clone()方法定义在Object类中。

clone()方法将对象复制了一份并返回给调用者。拷贝具体的含义将取决于对象所在的类。

一般而言，clone()方法满足：

1. 克隆对象与原对象不是同一个对象。即对任何的对象x：

x.clone() != x

2.克隆对象与原对象的类型一样。即对任何的对象x：

x.clone().getClass() == x.getClass()

3.如果对象x的equals()方法定义恰当，那么下式应该成立：

x.clone().equals(x)

因为一个定义良好的equals()方法就应该是用来比较内容是否相等的。

练习程序

程序1：CloneTest1进行拷贝：

1 public classCloneTest12 {3

4 public static void main(String[] args) throwsCloneNotSupportedException5 {6 Student student1 = newStudent();7 student1.setName("ZhangSan");8 student1.setAge(20);9

10 Student student2 = newStudent();11 student2 =(Student) student1.clone();12

13 System.out.println("拷贝得到的信息");14 System.out.println(student2.getName());15 System.out.println(student2.getAge());16 System.out.println("-------------");17

18 //修改第二个对象的信息

19 student2.setName("LiSi");20 student2.setAge(25);21

22 System.out.println("修改第二个对象的属性为lisi,25后：");23 System.out.println("第一个对象：");24 System.out.println(student1.getName());25 System.out.println(student1.getAge());26 System.out.println("第二个对象：");27 System.out.println(student2.getName());28 System.out.println(student2.getAge());29 System.out.println("-------------");30

31 //说明两个引用student1和student2指向的是不同的对象

32

33 }34 }35

36 class Student implementsCloneable37 {38 privateString name;39 private intage;40

41 publicString getName()42 {43 returnname;44 }45

46 public voidsetName(String name)47 {48 this.name =name;49 }50

51 public intgetAge()52 {53 returnage;54 }55

56 public void setAge(intage)57 {58 this.age =age;59 }60

61 @Override62 public Object clone() throwsCloneNotSupportedException63 {64 //注意此处要把protected改为public

65

66 Object object = super.clone();67

68 returnobject;69 }70 }

程序的输出是：

拷贝得到的信息

ZhangSan

20

-------------

修改第二个对象的属性为lisi,25后：

第一个对象：

ZhangSan

20

第二个对象：

LiSi

25

-------------

CloneTest1说明拷贝生成的是两个对象。

程序2：CloneTest2：在Student类中加入Teacher类的引用，进行拷贝：

1 public classCloneTest22 {3 public static void main(String[] args) throwsCloneNotSupportedException4 {5 Teacher teacher = newTeacher();6 teacher.setName("Teacher Zhang");7 teacher.setAge(40);8

9 Student2 student1 = newStudent2();10 student1.setName("ZhangSan");11 student1.setAge(20);12 student1.setTeacher(teacher);13

14 Student2 student2 =(Student2) student1.clone();15 System.out.println("拷贝得到的信息");16 System.out.println(student2.getName());17 System.out.println(student2.getAge());18 System.out.println(student2.getTeacher().getName());19 System.out.println(student2.getTeacher().getAge());20 System.out.println("-------------");21

22 //修改老师的信息

23 teacher.setName("Teacher Zhang has changed");24 System.out.println(student1.getTeacher().getName());25 System.out.println(student2.getTeacher().getName());26

27 //两个引用student1和student2指向不同的两个对象28 //但是两个引用student1和student2中的两个teacher引用指向的是同一个对象29 //所以说明是浅拷贝

30 }31

32 }33

34 class Teacher implementsCloneable35 {36 privateString name;37 private intage;38

39 publicString getName()40 {41 returnname;42 }43

44 public voidsetName(String name)45 {46 this.name =name;47 }48

49 public intgetAge()50 {51 returnage;52 }53

54 public void setAge(intage)55 {56 this.age =age;57 }58

59 }60

61 class Student2 implementsCloneable62 {63 privateString name;64 private intage;65 privateTeacher teacher;66

67 publicString getName()68 {69 returnname;70 }71

72 public voidsetName(String name)73 {74 this.name =name;75 }76

77 public intgetAge()78 {79 returnage;80 }81

82 public void setAge(intage)83 {84 this.age =age;85 }86

87 publicTeacher getTeacher()88 {89 returnteacher;90 }91

92 public voidsetTeacher(Teacher teacher)93 {94 this.teacher =teacher;95 }96

97 @Override98 public Object clone() throwsCloneNotSupportedException99 {100 Object object = super.clone();101 returnobject;102 }103

104 }

程序输出：

拷贝得到的信息

ZhangSan

20

Teacher Zhang

40

-------------

Teacher Zhang has changed

Teacher Zhang has changed

CloneTest2说明Object类的clone()方法进行的是浅拷贝。

程序3：把CloneTest2改为深复制：

首先在Teacher类中加入clone()方法(必须的，因为需要借此改为public，不然无法调用)，然后修改Student2类中的clone()方法，使得teacher引用也复制一份对象，然后用set方法设置回来。

1 public classCloneTest22 {3 public static void main(String[] args) throwsException4 {5 Teacher teacher = newTeacher();6 teacher.setName("Teacher Zhang");7 teacher.setAge(40);8

9 Student2 student1 = newStudent2();10 student1.setName("ZhangSan");11 student1.setAge(20);12 student1.setTeacher(teacher);13

14 Student2 student2 =(Student2) student1.clone();15 System.out.println("拷贝得到的信息");16 System.out.println(student2.getName());17 System.out.println(student2.getAge());18 System.out.println(student2.getTeacher().getName());19 System.out.println(student2.getTeacher().getAge());20 System.out.println("-------------");21

22 //修改老师的信息

23 teacher.setName("Teacher Zhang has changed");24 System.out.println(student1.getTeacher().getName());25 System.out.println(student2.getTeacher().getName());26

27 //两个引用student1和student2指向不同的两个对象28 //但是两个引用student1和student2中的两个teacher引用指向的是同一个对象29 //所以说明是浅拷贝30

31 //改为深复制之后，对teacher对象的修改只能影响第一个对象

32 }33 }34

35 class Teacher implementsCloneable36 {37 privateString name;38 private intage;39

40 publicString getName()41 {42 returnname;43 }44

45 public voidsetName(String name)46 {47 this.name =name;48 }49

50 public intgetAge()51 {52 returnage;53 }54

55 public void setAge(intage)56 {57 this.age =age;58 }59

60 @Override61 public Object clone() throwsCloneNotSupportedException62 {63 return super.clone();64 }65

66 }67

68 class Student2 implementsCloneable69 {70 privateString name;71 private intage;72 privateTeacher teacher;73

74 publicString getName()75 {76 returnname;77 }78

79 public voidsetName(String name)80 {81 this.name =name;82 }83

84 public intgetAge()85 {86 returnage;87 }88

89 public void setAge(intage)90 {91 this.age =age;92 }93

94 publicTeacher getTeacher()95 {96 returnteacher;97 }98

99 public voidsetTeacher(Teacher teacher)100 {101 this.teacher =teacher;102 }103

104 @Override105 public Object clone() throwsCloneNotSupportedException106 {107 //浅复制时：108 //Object object = super.clone();109 //return object;110

111 //改为深复制：

112 Student2 student = (Student2) super.clone();113 //本来是浅复制，现在将Teacher对象复制一份并重新set进来

114 student.setTeacher((Teacher) student.getTeacher().clone());115 returnstudent;116 }117

118 }

程序输出：

拷贝得到的信息

ZhangSan

20

Teacher Zhang

40

-------------

Teacher Zhang has changed

Teacher Zhang

利用序列化实现深复制

上面例子中的方法实现深复制比较麻烦。

下面介绍一种全新的方法：利用序列化来做深复制。

把对象写到流里的过程是序列化过程(Serialization)，而把对象从流中读出来的过程则叫做反序列化过程(Deserialization)。

应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。

在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象(实际上只是对象的一个拷贝)写到一个流里，再从流里读出来，便可以重建对象。

这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将其排除在复制过程之外。

注意Cloneable与Serializable接口都是marker Interface，也就是说它们只是标识接口，没有定义任何方法。

程序4：利用序列化实现深拷贝例子：CloneTest3

1 importjava.io.ByteArrayInputStream;2 importjava.io.ByteArrayOutputStream;3 importjava.io.ObjectInputStream;4 importjava.io.ObjectOutputStream;5 importjava.io.Serializable;6

7 public classCloneTest38 {9 public static void main(String[] args) throwsException10 {11 Teacher3 t = newTeacher3();12 t.setName("Teacher Wang");13 t.setAge(50);14

15 Student3 s1 = newStudent3();16 s1.setAge(20);17 s1.setName("ZhangSan");18 s1.setTeacher(t);19

20 Student3 s2 =(Student3) s1.deepClone();21

22 System.out.println("拷贝得到的信息:");23 System.out.println(s2.getName());24 System.out.println(s2.getAge());25 System.out.println(s2.getTeacher().getName());26 System.out.println(s2.getTeacher().getAge());27 System.out.println("---------------------------");28

29 //将复制后的对象的老师信息修改一下：

30 s2.getTeacher().setName("New Teacher Wang");31 s2.getTeacher().setAge(28);32

33 System.out.println("修改了拷贝对象的教师后：");34 System.out.println("拷贝对象的教师：");35 System.out.println(s2.getTeacher().getName());36 System.out.println(s2.getTeacher().getAge());37 System.out.println("原来对象的教师：");38 System.out.println(s1.getTeacher().getName());39 System.out.println(s1.getTeacher().getAge());40

41 //由此证明序列化的方式实现了对象的深拷贝

42

43 }44

45 }46

47 class Teacher3 implementsSerializable48 {49 privateString name;50 private intage;51

52 publicString getName()53 {54 returnname;55 }56

57 public voidsetName(String name)58 {59 this.name =name;60 }61

62 public intgetAge()63 {64 returnage;65 }66

67 public void setAge(intage)68 {69 this.age =age;70 }71

72 }73

74 class Student3 implementsSerializable75 {76 privateString name;77 private intage;78 privateTeacher3 teacher;79

80 publicString getName()81 {82 returnname;83 }84

85 public voidsetName(String name)86 {87 this.name =name;88 }89

90 public intgetAge()91 {92 returnage;93 }94

95 public void setAge(intage)96 {97 this.age =age;98 }99

100 publicTeacher3 getTeacher()101 {102 returnteacher;103 }104

105 public voidsetTeacher(Teacher3 teacher)106 {107 this.teacher =teacher;108 }109

110 public Object deepClone() throwsException111 {112 //序列化

113 ByteArrayOutputStream bos = newByteArrayOutputStream();114 ObjectOutputStream oos = newObjectOutputStream(bos);115

116 oos.writeObject(this);117

118 //反序列化

119 ByteArrayInputStream bis = newByteArrayInputStream(bos.toByteArray());120 ObjectInputStream ois = newObjectInputStream(bis);121

122 returnois.readObject();123 }124

125 }

程序输出：

拷贝得到的信息:

ZhangSan

20

Teacher Wang

50

---------------------------

修改了拷贝对象的教师后：

拷贝对象的教师：

New Teacher Wang

28

原来对象的教师：

Teacher Wang

50

serialVersionUID问题

当一个类实现了Serializable接口时，表明该类可被序列化，这个时候Eclipse会给出一个警告，要求你为该类定义一个字段，该字段名字为serialVersionUID，类型为long，提示信息如下：

The serializable class Teacher3 does not declare a static final serialVersionUID field of type long。

在Eclipse中有两种生成方式：

一个是默认的1L；

private static final long serialVersionUID = 1L;

一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：

private static final long serialVersionUID = -932183802511122207L;

如果你没有考虑到兼容性的问题，就把它关掉，不过有这个功能是好的，只要任何类别实现了Serializable接口，如果没有加入serialVersionUID，Eclipse都会给你提示，这个serialVersionUID为了让该类别Serializable向后兼容。

如果你的对象序列化后存到硬盘上面后，你却更改了类的field(增加或减少或改名)，当你反序列化时，就会出现异常，这样就会造成不兼容性的问题。

但当serialVersionUID相同时，它就会将不一样的field以type的缺省值Deserialize，这个可以避开不兼容性的问题。