ArrayList深拷贝的一种实现方法

原帖地址：http://suihr.javaeye.com/blog/469616

 

大家应该理解浅拷贝和深拷贝的区别：

浅拷贝：被复制对象的任何变量都含有和原来的对象相同的值，而任何的对其他对象的引用仍然指向原来的对象。对拷贝后的引用的修改，还能影响原来的对象。

深拷贝：把要复制的对象所引用的对象都复制了一遍，对现在对象的修改不会影响原有的对象。

如果大家还不理解，在网上看到一个人的比喻很有意思：

就好比一个爸爸一个儿子
浅拷贝：你克隆一下，只得到一个爸爸，这是浅
深拷贝：你克隆一下，既得到了爸爸，又得到了儿子，这是深
另外，如果你克隆的对象里面还包括其他对象，比如汽车对象里还有座位对象，那么浅的结果就是汽车被拷贝了，座位并没有，深的话，就是一起都拷贝了。

下面，给大家说一下如何实现ArrayList的深拷贝的一种实现方式：

有一个类Userinfo，需要实现Serializable接口，可以序列化。

Java代码

1. package test;   
2.   
3. import java.io.Serializable;   
4.   
5. public class Userinfo implements Serializable    
6. {   
7.     private int id;   
8.     private String name;   
9.     public int getId() {   
10.         return id;   
11.     }   
12.     public void setId(int id) {   
13.         this.id = id;   
14.     }   
15.     public String getName() {   
16.         return name;   
17.     }   
18.     public void setName(String name) {   
19.         this.name = name;   
20.     }   
21.        
22. }  

 

下面是我的一个测试类：

 

Java代码

1. package test;   
2.   
3. import java.io.ByteArrayInputStream;   
4. import java.io.ByteArrayOutputStream;   
5. import java.io.IOException;   
6. import java.io.ObjectInputStream;   
7. import java.io.ObjectOutputStream;   
8. import java.util.ArrayList;   
9. import java.util.List;   
10.   
11. public class TestMain {   
12.   
13.     /**  
14.      * @param args  
15.      */  
16.     public static void main(String[] args) {   
17.         // TODO Auto-generated method stub   
18.         List src = new ArrayList(2);   
19.         Userinfo ui1 = new Userinfo();   
20.         ui1.setId(1);   
21.         ui1.setName("aaa");   
22.         src.add(ui1);   
23.            
24.         Userinfo ui2 = new Userinfo();   
25.         ui1.setId(2);   
26.         ui1.setName("bbb");   
27.         src.add(ui2);   
28.            
29.         List dest = new ArrayList(2);   
30.            
31.         TestMain test = new TestMain();   
32.        
33.         try {   
34.             dest = test.deepCopy(src);   
35.         } catch (IOException e) {   
36.             // TODO Auto-generated catch block   
37.             e.printStackTrace();   
38.         } catch (ClassNotFoundException e) {   
39.             // TODO Auto-generated catch block   
40.             e.printStackTrace();   
41.         }   
42.        
43.            
44.         System.out.println(src==dest);   
45.         Userinfo u = (Userinfo)src.get(0);   
46.         Userinfo uu = (Userinfo)dest.get(0);   
47.         uu.setName("dkkdkddk");   
48.         System.out.println(u.getName());   
49.            
50.         System.out.println(uu.getName());   
51.        
52.     }   
53.   
54.     public List deepCopy(List src) throws IOException, ClassNotFoundException{   
55.         ByteArrayOutputStream byteOut = new ByteArrayOutputStream();   
56.         ObjectOutputStream out = new ObjectOutputStream(byteOut);   
57.         out.writeObject(src);   
58.        
59.         ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());   
60.         ObjectInputStream in =new ObjectInputStream(byteIn);   
61.         List dest = (List)in.readObject();   
62.         return dest;   
63.     }   
64. }  

就是把ArrayList的原来的对象进行序列化，然后通过反序列化读取出来，就可以了。

当然，记着放到集合中的元素也要能够序列化，所以必须实现Serializable接口。

在此，也欢迎大家提出其它的ArrayList深拷贝实现方法。