利用java序列化进行对象深Clone

在java语言里深复制一个对象，通常可以使对象实现Serializable接口，然后把对象（实际上是对象的一个copy），写到一个流里面，便可重复建立对象。

这样做被复制的对象与被复制对象里面的引用都是可以被一并深复制的，不同于Object基类的Clone方法（浅复制：如果被复制的对象存在其他对象的引用，复制一个引用指向原对象的实例）。废话不多说Code如下：

[java]  view plain copy

1. import java.io.ByteArrayInputStream;  
2. import java.io.ByteArrayOutputStream;  
3. import java.io.IOException;  
4. import java.io.ObjectInputStream;  
5. import java.io.ObjectOutputStream;  
6. import java.io.Serializable;  
7.   
8.   
9. public class CloneTest {  
10.     public static void main(String[] args) throws IOException, ClassNotFoundException {  
11.         Teacher t = new Teacher();  
12.         t.setName("Teacher xin");  
13.         t.setAge(30);  
14.           
15.         Student s = new Student();  
16.         s.setName("Student xiaoxin");  
17.         s.setAge(20);  
18.         s.setTeacher(t);  
19.           
20.         System.out.println("s name="+s.getName());  
21.         System.out.println("s age="+s.getAge());  
22.         System.out.println("s t name="+s.getTeacher().getName());  
23.         System.out.println("s t age="+s.getTeacher().getAge());  
24.         System.out.println("-------------------");  
25.           
26.         Student sCopy = (Student)s.deepCopy();  
27.         sCopy.getTeacher().setName("Teacher mao");  
28.         //下面运行的结果看出对Student的引用Teacher类进行了深复制  
29.         System.out.println("sCopy t name="+sCopy.getTeacher().getName());  
30.         System.out.println("-------------------");  
31.         System.out.println("s t name="+s.getTeacher().getName());  
32.     }  
33.   
34. }  
35.   
36. class Teacher implements Serializable{  
37.       
38.     private static final long serialVersionUID = -2380977769309339400L;  
39.     private String name;  
40.     private int age;  
41.     public int getAge() {  
42.         return age;  
43.     }  
44.     public void setAge(int age) {  
45.         this.age = age;  
46.     }  
47.     public String getName() {  
48.         return name;  
49.     }  
50.     public void setName(String name) {  
51.         this.name = name;  
52.     }  
53.       
54. }  
55.   
56. class Student implements Serializable{  
57.       
58.     private static final long serialVersionUID = 739748261443702736L;  
59.     private String name;  
60.     private int age;  
61.     public int getAge() {  
62.         return age;  
63.     }  
64.     public void setAge(int age) {  
65.         this.age = age;  
66.     }  
67.   
68.     private Teacher teacher;  
69.     public Teacher getTeacher() {  
70.         return teacher;  
71.     }  
72.     public void setTeacher(Teacher teacher) {  
73.         this.teacher = teacher;  
74.     }  
75.     public String getName() {  
76.         return name;  
77.     }  
78.     public void setName(String name) {  
79.         this.name = name;  
80.     }  
81.     /** 
82.      * 把对象读到字节流中在读出来 
83.      * @return 
84.      * @throws IOException 
85.      * @throws ClassNotFoundException 
86.      */  
87.     public Object deepCopy() throws IOException, ClassNotFoundException{  
88.         ByteArrayOutputStream bop = new ByteArrayOutputStream();  
89.           
90.         ObjectOutputStream oos = new ObjectOutputStream(bop);  
91.           
92.         oos.writeObject(this);  
93.           
94.         ByteArrayInputStream bis = new ByteArrayInputStream(bop.toByteArray());  
95.           
96.         ObjectInputStream ois = new ObjectInputStream(bis);  
97.           
98.         return ois.readObject();  
99.           
100.     }  
101. }  

运行结果：

s name=Student xiaoxin
s age=20
s t name=Teacher xin
s t age=30
-------------------
sCopy t name=Teacher mao
-------------------
s t name=Teacher xin