java 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类对象是不易被外部修改和破坏的。

 

在下面的例子中，我们有一个可变Employee对象的集合，每个对象包含name和designation字段，将它们保存在HashSet中。我们用java.util.Collection接口中的addAll()方法来创建这个集合的一个拷贝。在这之后，我们修改原有集合中的每个Employee对象的designation字段，希望这个改变不会影响到拷贝集合，但事与愿违，解决这个问题的方法是深度拷贝集合类中的元素。

[java]  view plain  copy

1. import java.util.Collection;   
2. import java.util.HashSet;   
3. import java.util.Iterator;   
4. import org.slf4j.Logger;   
5. import org.slf4j.LoggerFactory;   
6. /**  
7.   * Java program to demonstrate copy constructor of Collection provides shallow  
8.   * copy and techniques to deep clone Collection by iterating over them.  
9.   * @author http://javarevisited.blogspot.com  
10.   */   
11. public class CollectionCloningTest {   
12.     private static final Logger logger = LoggerFactory.getLogger(CollectionCloningclass);   
13.       
14.     public static void main(String args[]) {   
15.       
16.         // deep cloning Collection in Java   
17.         Collection org = new HashSet();   
18.         org.add(new Employee("Joe", "Manager"));   
19.         org.add(new Employee("Tim", "Developer"));   
20.         org.add(new Employee("Frank", "Developer"));   
21.           
22.         // creating copy of Collection using copy constructor   
23.         Collection copy = new HashSet(org);   
24.           
25.         logger.debug("Original Collection {}", org);   
26.         logger.debug("Copy of Collection {}", copy );   
27.           
28.         Iterator itr = org.iterator();   
29.         while(itr.hasNext()){   
30.             itr.next().setDesignation("staff");   
31.         }   
32.           
33.         logger.debug("Original Collection after modification {}", org);   
34.         logger.debug("Copy of Collection without modification {}", copy );   
35.           
36.         // deep Cloning List in Java   
37.           
38.     }   
39. }  
40. class Employee {   
41.     private String name;   
42.     private String designation;   
43.       
44.     public Employee(String name, String designation) {   
45.         this.name = name; this.designation = designation;   
46.     }   
47.     public String getDesignation() {   
48.         return designation;   
49.     }   
50.       
51.     public void setDesignation(String designation) {   
52.         this.designation = designation;   
53.     }   
54.       
55.     public String getName() {   
56.         return name;   
57.     }   
58.       
59.     public void setName(String name) {   
60.         this.name = name;   
61.     }   
62.       
63.     @Override public String toString() {   
64.         return String.format("%s: %s", name, designation );   
65.     }   
66. }  

输出：

[html]  view plain  copy

1. - Original Collection [Joe: Manager, Frank: Developer, Tim: Developer]   
2. - Copy of Collection [Joe: Manager, Frank: Developer, Tim: Developer]   
3. - Original Collection after modification [Joe: staff, Frank: staff, Tim: staff]   
4. - Copy of Collection without modification [Joe: staff, Frank: staff, Tim: staff]  

可以很清楚地看到修改原有集合的Employee对象（即修改designation字段为"staff"）也会反映到拷贝集合中，因为克隆是浅拷贝，它指向的是堆中同一个Employee对象。为了修复这个问题，我们需要遍历集合深度拷贝所有Employee对象，而在这之前，我们需要为Employee对象覆写clone方法。

1）让Employee类实现Cloneable接口；

2）在Employee类中添加下面的clone()方法；

[java]  view plain  copy

1. @Override   
2. protected Employee clone() {   
3.     Employee clone = ;   
4.     try{   
5.         clone = (Employee) super.clone();   
6.           
7.     }catch(CloneNotSupportedException e){   
8.         throw new RuntimeException(e);  // won't happen   
9.     }   
10.       
11.     return clone;   
12. }  

3）使用下面的代码，用Java中深度拷贝取代拷贝构造函数；

[java]  view plain  copy

1. Collection<Employee> copy = new HashSet<Employee>(org.size());   
2. Iterator<Employee> iterator = org.iterator();   
3. while(iterator.hasNext()){   
4.     copy.add(iterator.next().clone());   
5. }  

4）为修改后的集合运行同样的代码，会得到不同的输出：

[html]  view plain  copy

1. - Original Collection after modification  [Joe: staff, Tim: staff, Frank: staff]  
2. - Copy of Collection without modification [Frank: Developer, Joe: Manager, Tim: Developer]  

可以看出克隆后的和原有集合相互独立，分别指向不同的对象。

这便是Java如何克隆集合的所有内容，现在我们明白集合类中各种拷贝构造函数，如List或Set中addAll()方法，仅仅实现了集合的浅拷贝，即原有集合和拷贝的集合指向相同的对象。这也便要求在集合中存储任何对象，必须支持深度拷贝操作。

PS: 原Blog中的代码执行可能会遇到一些问题，但关键是这中间的思想很重要。

链接：

How to create Immutable Class and Object in Java - Tutorial Example

Difference between deep copy vs Shadow Cloning in Java

Collection interview  questions answers

How clone method works in Java