java集合深度复制

1. java关于 克隆接口cloneable问题

对于你的例子中，属性whenBuilt才是对象，因此可以简单的修改一下clone方法即可
/** Override the protected clone method defined in the Object
class, and strengthen its accessibility */
public Object clone() {
try {
House t = (House)super.clone();
t.whenBuilt = (Date) this.whenBuilt.clone();
return t;
}
catch (CloneNotSupportedException ex) {
return null;
}
}
对于复杂的，可以利用串行化进行深度复制，下面的完整实例中的deepClone就是相应的代码（此时，House类需要实现序列化的接口：java.io.Serializable）
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;

public class House implements Cloneable, Serializable{
private int id;
private double area;
private java.util.Date whenBuilt;

public House(int id, double area) {
this.id = id;
this.area = area;
whenBuilt = new java.util.Date();
}

public double getId() {
return id;
}

public double getArea() {
return area;
}

public java.util.Date getWhenBuilt() {
return whenBuilt;
}

/** Override the protected clone method defined in the Object
class, and strengthen its accessibility */
public Object clone() {
try {
House t = (House)super.clone();
t.whenBuilt = (Date) this.whenBuilt.clone();
return t;
}
catch (CloneNotSupportedException ex) {
return null;
}
}
public Object deepClone() {
ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
ObjectOutputStream oo = new ObjectOutputStream(out);
oo.writeObject(this);

ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream oi = new ObjectInputStream(in);
return oi.readObject();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

public static void main(String[] args) {
House house1 = new House(1,1750.50);
House house2 = (House)house1.deepClone();
System.out.println(house1.whenBuilt == house2.whenBuilt );
}
}

2. java如何深度一个object

java深复制的例子：
1、创建Employer类，实现Cloneable接口：
class Employer implements Cloneable{
private String username;

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}

@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

2、创建Employee类，实现Cloneable接口，并改写clone方法，实现深复制：
class Employee implements Cloneable{
private String username;
private Employer employer;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Employer getEmployer() {
return employer;
}
public void setEmployer(Employer employer) {
this.employer = employer;
}

@Override
public Object clone() throws CloneNotSupportedException {
//克隆Employee对象并手动的进一步克隆Employee对象中包含的Employer对象
Employee employee = (Employee)super.clone();
employee.setEmployer((Employer) employee.getEmployer().clone());
return employee;
}
}

3、这样，在客户端拷贝的两个Employee对象的Employer就互不影响了：
public static void main(String[] args) throws CloneNotSupportedException {
Employer employer = new Employer();
employer.setUsername("arthinking");

Employee employee = new Employee();
employee.setUsername("Jason");
employee.setEmployer(employer);

//employee2由employee深复制得到
Employee employee2 = (Employee) employee.clone();
//这样两个employee各自保存了两个employer
employee2.getEmployer().setUsername("Jason");
System.out.println(employee.getEmployer().getUsername());
System.out.println(employee2.getEmployer().getUsername());
}