⑴ java,,"淺克隆，只復制一個對象 ，深克隆 對象和引用一起復制"有java實例嗎不理解啊

對只包抄含進本類型的類來說襲，無所謂深克隆。但是一個類包含集合類或者復雜的類，就要考慮二者的區別了。

class Student {
private int id;
private Address address;
private ArrayList<Book> bookList;
}
對於以上類的一個對象a和克隆類 o來說：
淺克隆：
a !=o 但是 a.address == o.address, a.bookList == o.bookList
深克隆：
a !=o 但是 a.address != o.address, a.bookList != o.bookList
並且 bookList中的每個元素不是相同對象。
簡言之， 淺克隆只復制本對象，深克隆除了本對象，其兒子、孫子、....都要克隆。
以上純手敲，有錯請包涵。

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

⑶ java深度復制問題：

for(int i=0;i<e.children.size();i++){ 這里遍歷childen的對象錯了，應該是「this.children」，並且要注意是否為空。
Elem temp = (Elem)children.get(i).clone(); 這句已表達是深度復制。

⑷ java bean 如何過濾某些屬性進行深度克隆

序列化bean,先寫入，後讀出。這兩個bean 就毫無關系了。但內容一模一樣。

publicSerializableObject(Serializablesobj){
try{
ByteArrayOutputStreambos=newByteArrayOutputStream();

ObjectOutputStreamoos=newObjectOutputStream(bos);

oos.writeObject(sobj);

ByteArrayInputStreambis=newByteArrayInputStream(bos.toByteArray());

ObjectInputStreamois=newObjectInputStream(bis);

return(Serializable)ois.readObject();
}catch(Exceptione){
returnnull;
}

}


可以參考一下。不過 要求實現 Serializable介面。


原文：

html">http://tieba..com/p/3205322191

⑸ java深度拷貝和淺度拷貝的問題

看來你並沒理解錯克隆，反而是改變東西的方法不對。
先還是講講克隆吧。
是的，上面的clone方法也就是Object的Clone方法是淺表復制，看看他的API說的：
「此方法會創建此對象的類的一個新實例，並像通過分配那樣，嚴格使用此對象相應欄位的內容初始化該對象的所有欄位；……。所以，此方法執行的是該對象的「淺表復制」，而不「深層復制」操作。 」
這你沒理解錯。
但你測試的方法貌似有問題，讓人不知你想干什麼。
本來sb1、sb2的a欄位內容相同的。這兩個欄位代表兩個對象，所謂倆對象，說白了實際上都是一個4位元組空間，存的是StringBuffer對象地址，也就是所謂a對象，實際上包含兩個東西，一個是a這個指針（我是在說JAVA），另一個指的是這個指針指向的堆棧裡面的空間（再復雜就不說了，參閱《JAVA虛擬機》）。相同也就意味著兩個變數指向的對象空間一樣。
這樣的話，如果你調用sb1.a.put...類似的方法朝a中放東西，那sb2也會變。

可你直接把sb1的a換了，也就是讓a指向另一個你new的空間。這樣和sb2有什麼關系，而且你以後再改sb1的a，sb2也不會變。
不說了，累。不懂就問我。

⑹ java中的淺克隆和深克隆是什麼

克隆是指克隆對象，在堆空間復制一塊內存，是完全的兩個對象，不是指針指向！淺克隆是指克隆一個對象，而該對象的屬性只是基本數據類型，只克隆出該對象！深度克隆是指克隆的目標裡面還有引用類型，引用類型里還有引用類型，同時把引用類型克隆出來叫深度克隆！常用的方法有兩種，第一，需克隆的對象實現cloneable介面；第二，使用commons包提供的克隆方法。這兩種方法都能實現深度克隆！

⑺ java中如何實現一個類的深克隆的代碼

類的屬性如果是引用類型的 那麼繼續執行屬性的 clone方法即可（屬性要實現Cloneable介面）

⑻ java深克隆

deep ，自己看：
http://blog.csdn.net/liuchao1211/article/details/3277955

⑼ java 深度復制

House不是單例吧？h1和h2的地址不一樣第一個肯定是false.house內部怎麼樣這個光看這些真難看出。

⑽ java中深克隆與淺克隆的區別

深克隆與淺克隆

大家知道，對象是互相引用的，即對象中可能包含了另一個對象的引用，舉例如：有一個Order對象，Order對象中又包含了LineItems對象，然後LineItems對象又包含了Item對象。

好了，現在我有一個Order對象order1,它包含了一個LineItems對象items，這表示的是有一個訂單order1，訂單的內容是items。

好的，現在有另一個客戶想要一份訂單，內容跟order1完全一樣，那麼在系統的邏輯層我們怎麼做呢？很簡單，order2=order1.clone(). 我們知道clone方法是在內存中生成一個新的對象，而不是只得到原對象的引用。這時候，有人說話了：「哦，明白了我們對order2的成員變數進行修改，是不會影響order1的。」 很可惜，這句話只對了一半。

假設order類有一個成員變數name，當然改變order2.name不會影響order1.name，因為他們在不同的內存區域。但是如果改變 order1.items呢？很遺憾，簡單地使用order1.clone，是會影響到order2.items的。原因很簡單，就是因為clone方法默認的是淺克隆，即不會克隆對象引用的對象，而只是簡單地復制這個引用。所以在上例中，items對象在內存中只有一個，order1和order2都指向它，任何一個對象對它的修改都會影響另一個對象。

那相對淺克隆，深克隆自然就是會克隆對象引用的對象了。也就是說，在上例中，改變order1.items並不會影響order2.items了。因為內存中有兩個一樣的items。

如果實現深克隆？

一個方法自然是重寫clone方法，添加如order.items=(LineItems)items.clone()的語句，也就是人為地添加對引用對象的復制。這個方法的缺點是如果引用對象有很多，或者說引用套引用很多重，那麼太麻煩了。業界常用的方法是使用串列化然後反串列化的方法來實現深克隆。由於串列化後，對象寫到流中，所有引用的對象都包含進來了，所以反串列化後，對等於生成了一個完全克隆的對象。絕！

這個方法的要求是對象（包括被引用對象）必須事先了Serializable介面，否則就要用transient關鍵字將其排除在復制過程中。