一些不靠谱的java.util.List深复制方法

之前探讨过Java数组的深复制问题，现在来说说<一些不靠谱的java.util.List深复制方法>。为什么不说<靠谱的深复制方法>呢？因为在寻找探索<靠谱的深复制方法>的过程中，我发现了这些不靠谱的方法，写下来是希望给自己和他人提个醒，不要犯这样的错误。

 

这是下面要频繁使用的一个JavaBean

 

Java代码  

1. class Person implements Serializable{  
2.     private int age;  
3.     private String name;  
4.       
5.     public Person(){};  
6.     public Person(int age,String name){  
7.         this.age=age;  
8.         this.name=name;  
9.     }  
10.       
11.     public int getAge() {  
12.         return age;  
13.     }  
14.     public void setAge(int age) {  
15.         this.age = age;  
16.     }  
17.     public String getName() {  
18.         return name;  
19.     }  
20.     public void setName(String name) {  
21.         this.name = name;  
22.     }  
23.       
24.     public String toString(){  
25.         return this.name+"-->"+this.age;  
26.     }  
27.       
28. }  

 

 

后台打印List集合的一个静态方法

 

Java代码  

1. public static <T> void printList(List<T> list){  
2.     System.out.println("---begin---");  
3.     for(T t : list){  
4.         System.out.println(t);  
5.     }  
6.     System.out.println("---end---");  
7. }  

 

 

后台打印数组的一个静态方法

 

Java代码  

1. public static <T> void printArray(T[] array){  
2.     System.out.println("---begin---");  
3.     for(T t : array){  
4.         System.out.println(t);  
5.     }  
6.     System.out.println("---end---");  
7. }  

 

 

这是数据源集合，下面将通过各种方法企图来深复制该List集合中的元素

 

Java代码  

1. List<Person> srcList=new ArrayList<Person>();  
2. Person p1=new Person(20,"123");  
3. Person p2=new Person(21,"ABC");  
4. Person p3=new Person(22,"abc");  
5. srcList.add(p1);  
6. srcList.add(p2);  
7. srcList.add(p3);  

  

1、遍历循环复制

 

Java代码  

1. List<Person> destList=new ArrayList<Person>(srcList.size());  
2. for(Person p : srcList){  
3.     destList.add(p);  
4. }  
5.           
6. printList(destList);  
7. srcList.get(0).setAge(100);  
8. printList(destList);  

 

 上面的代码在add时候，并没有new Person()操作。因此，在srcList.get(0).setAge(100);破坏源数据时，目标集合destList中元素的输出同样受到了影响，原因是浅复制造成的。

 

后台输出结果代码  

1. ---begin---  
2. 123-->20  
3. ABC-->21  
4. abc-->22  
5. ---end---  
6. ---begin---  
7. 123-->100  
8. ABC-->21  
9. abc-->22  
10. ---end---  

 

2、使用List实现类的构造方法

 

Java代码  

1. List<Person> destList=new ArrayList<Person>(srcList);  
2. printList(destList);  
3. srcList.get(0).setAge(100);  
4. printList(destList);  

 

 通过ArrayList的构造方法来复制集合内容，同样是浅复制，在修改了源数据集合后，目标数据集合对应内容也发生了改变。在查阅资料的过程中，看到有人说这种方式 能实现深复制，其实这是不对的。对于某些特殊的元素，程序运行的结果形似深复制，其实还是浅复制。具体一会儿再说。

 

后台打印输出代码  

1. ---begin---  
2. 123-->20  
3. ABC-->21  
4. abc-->22  
5. ---end---  
6. ---begin---  
7. 123-->100  
8. ABC-->21  
9. abc-->22  
10. ---end---  

 

3、使用list.addAll()方法

 

Java代码  

1. List<Person> destList=new ArrayList<Person>();  
2. destList.addAll(srcList);  
3. printList(destList);  
4. srcList.get(0).setAge(100);  
5. printList(destList);  

 

 java.util.list.addAll()方法同样是浅复制

 

后台打印输出代码  

1. ---begin---  
2. 123-->20  
3. ABC-->21  
4. abc-->22  
5. ---end---  
6. ---begin---  
7. 123-->100  
8. ABC-->21  
9. abc-->22  
10. ---end---  

 

4、使用System.arraycopy()方法

 

Java代码  

1. Person[] srcPersons=srcList.toArray(new Person[0]);  
2. Person[] destPersons=new Person[srcPersons.length];  
3. System.arraycopy(srcPersons, 0, destPersons, 0, srcPersons.length);  
4. //destPersons=srcPersons.clone();  
5.   
6. printArray(destPersons);  
7. srcPersons[0].setAge(100);  
8. printArray(destPersons);  
9.   
10. List<Person> destList=Arrays.asList(destPersons);  
11. printList(destList);  

这种方式虽然比较变态，但是起码证明了System.arraycopy()方法和clone()是不能对List集合进行深复制的。

 

 

5、使用序列化方法（相对靠谱的方法）

 

Java代码  

1. public static <T> List<T> deepCopy(List<T> src) throws IOException, ClassNotFoundException {  
2.     ByteArrayOutputStream byteOut = new ByteArrayOutputStream();  
3.     ObjectOutputStream out = new ObjectOutputStream(byteOut);  
4.     out.writeObject(src);  
5.   
6.     ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());  
7.     ObjectInputStream in = new ObjectInputStream(byteIn);  
8.     @SuppressWarnings("unchecked")  
9.     List<T> dest = (List<T>) in.readObject();  
10.     return dest;  
11. }  

 

 

Java代码  

1. List<Person> destList=deepCopy(srcList);  
2. printList(destList);  
3. srcList.get(0).setAge(100);  
4. printList(destList);  

这是比较靠谱的做法，听说是国外某位程序大师提出来的。实际运行的结果也同样是正确的。

后台打印输出代码  

1. ---begin---  
2. 123-->20  
3. ABC-->21  
4. abc-->22  
5. ---end---  
6. ---begin---  
7. 123-->20  
8. ABC-->21  
9. abc-->22  
10. ---end---  

 

 

其实，上面这些不靠谱List深复制的做法在某些情况是可行的，这也是为什么有些人说这其中的一些做法是可以实现深复制的原因。哪些情况下是可行（本质上可能还是不靠谱）的呢？比如List<String>这样的情况。我上面使用的是List<Person>，它和List<String>的区别就在于Person类和String类的区别，Person类提供了破坏数据的2个setter方法。因此，在浅复制的情况下，源数据被修改破坏之后，使用相同引用指向该数据的目标集合中的对应元素也就发生了相同的变化。

因此，在需求要求必须深复制的情况下，要是使用上面提到的方法，请确保List<T>中的T类对象是不易被外部修改和破坏的。