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

最新推荐文章于 2022-04-19 11:42:53 发布

0cool

最新推荐文章于 2022-04-19 11:42:53 发布

阅读量3w

点赞数 3

分类专栏： Java 文章标签： Java Collection DeepCloning ShadowCopy

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

原英文链接：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字段，希望这个改变不会影响到拷贝集合，但事与愿违，解决这个问题的方法是深度拷贝集合类中的元素。

import java.util.Collection; 
import java.util.HashSet; 
import java.util.Iterator; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
/** 
  * Java program to demonstrate copy constructor of Collection provides shallow 
  * copy and techniques to deep clone Collection by iterating over them. 
  * @author http://javarevisited.blogspot.com 
  */ 
public class CollectionCloningTest { 
	private static final Logger logger = LoggerFactory.getLogger(CollectionCloningclass); 
	
	public static void main(String args[]) { 
	
		// deep cloning Collection in Java 
		Collection org = new HashSet(); 
		org.add(new Employee("Joe", "Manager")); 
		org.add(new Employee("Tim", "Developer")); 
		org.add(new Employee("Frank", "Developer")); 
		
		// creating copy of Collection using copy constructor 
		Collection copy = new HashSet(org); 
		
		logger.debug("Original Collection {}", org); 
		logger.debug("Copy of Collection {}", copy ); 
		
		Iterator itr = org.iterator(); 
		while(itr.hasNext()){ 
			itr.next().setDesignation("staff"); 
		} 
		
		logger.debug("Original Collection after modification {}", org); 
		logger.debug("Copy of Collection without modification {}", copy ); 
		
		// deep Cloning List in Java 
		
	} 
}
class Employee { 
	private String name; 
	private String designation; 
	
	public Employee(String name, String designation) { 
		this.name = name; this.designation = designation; 
	} 
	public String getDesignation() { 
		return designation; 
	} 
	
	public void setDesignation(String designation) { 
		this.designation = designation; 
	} 
	
	public String getName() { 
		return name; 
	} 
	
	public void setName(String name) { 
		this.name = name; 
	} 
	
	@Override public String toString() { 
		return String.format("%s: %s", name, designation ); 
	} 
}

输出：

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

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

1）让Employee类实现Cloneable接口；

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

@Override 
protected Employee clone() { 
	Employee clone = null; 
	try{ 
		clone = (Employee) super.clone(); 
		
	}catch(CloneNotSupportedException e){ 
		throw new RuntimeException(e);  // won't happen 
	} 
	
	return clone; 
}

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

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

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

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

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