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());
}