【转】Java如何克隆集合——深度拷贝ArrayList和HashSet

原文网址：http://blog.csdn.net/cool_sti/article/details/21658521

原英文链接：http://javarevisited.blogspot.hk/2014/03/how-to-clone-collection-in-java-deep-copy-vs-shallow.html

 

程序员通常会误用集合类（如List、Set、ArrayList、HashSet）所提供的拷贝构造函数或其它方法来完成集合的拷贝。值得记住的一点是，Java中集合提供的拷贝构造函数只支持浅拷贝而不是深拷贝，这意味着存储在原有List和克隆List中的对象会保持一致，并指向Java堆中同一内存地址。造成这一误解的原因是它采用Collections对不可变对象进行了浅拷贝，正是由于对象不可变，两个集合指向相同对象也是合乎情理的。正是如此，所以保存在池中的String，更新其中一个不会影响到其它对象。问题来了，当我们使用ArrayList的拷贝构造函数来创建Employee对象列表的克隆时，其中Employee对象是可变的，在这个例子中如果原有集合修改了其中一个Employee，改变同样也会发生在拷贝的集合中，但这并不是我们所希望的。在几乎所有的例子中，克隆应该和原有对象独立开来。能够避免这个问题的方法是采用深度拷贝集合，即递归拷贝对象直到访问到原语或不可变对象。在这篇文章中，我们将介绍一种深度拷贝集合的方法，如Java中的ArrayList或HashSet。顺便提一下，如果你了解浅拷贝和深拷贝之间的区别，那么你会很轻松地掌握深度拷贝集合的机理。

Java集合中的深度拷贝

在下面的例子中，我们有一个可变Employee对象的集合，每个对象包含name和designation字段，将它们保存在HashSet中。我们用java.util.Collection接口中的addAll()方法来创建这个集合的一个拷贝。在这之后，我们修改原有集合中的每个Employee对象的designation字段，希望这个改变不会影响到拷贝集合，但事与愿违，解决这个问题的方法是深度拷贝集合类中的元素。
[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  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 plaincopy在CODE上查看代码片派生到我的代码片
 
  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 plaincopy在CODE上查看代码片派生到我的代码片
 
  1. @Override   
  2. protected Employee clone() {   
  3.     Employee clone = null;   
  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 plaincopy在CODE上查看代码片派生到我的代码片
 
  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 plaincopy在CODE上查看代码片派生到我的代码片
 
  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中的代码执行可能会遇到一些问题，但关键是这中间的思想很重要。
 
链接：

posted on 2015-08-16 11:41  wi100sh  阅读(9179)  评论(0)  编辑  收藏  举报

导航