java復制一個對象

A. java對象癿深復制和淺復制區別指什麼幫幫忙~~

淺拷貝：僅復制引用，即兩個引用指向同一個對象，如：
String aString = "hello";
String bString = aString;

深拷貝：復制對象的內容，Java里通過實現Clonnable並覆蓋clone方法實現，具體深度由clone的實現決定，如：
public class People implements Clonnable{
private int age;
private String name;

public void setAge(int age){
this.age = age;
}

public int getAge(){
return this.age;
}

public void setName(String name){
this.name = name;
}

public String getAge(){
return this.name;
}

public Object clone(){
People people = new People();
people.setAge(this.age);
people.setName(this.name);

return people;
}
}

如果對您有幫助，請記得採納為滿意答案，謝謝！祝您生活愉快！

vaela

B. Java中Object.clone方法的用途是什麼

clone方法是用來復制一個對象。不同於「=」。
對於值類型的數據是可以通過「=」來實現復制的。但是對於引用類型的對象，「=」只能復制其內存地址，使對象的引用指向同一個對象，而不會創建新的對象。clone則可以創建與原來對象相同的對象。舉個例子：
有一個Car類
Car c1 = new Car();
Car c2 = c1;
這兩句事實上只創建了一個對象。只不過c1和c2指向了同一個對象。
如果上面的兩句改為：
Car c1 = new Car();
Car c2 = c1.clone();
那麼就有了兩個對象，而且這兩個對象的內容是一樣的。（所有的屬性值相同）
同時，我想說的是一樓的使用，雖然程序本身沒有錯誤，但是用date.clone()添加到list當中，會再次創建date的對象，消耗內存資源，這是編程的忌諱。特別是編寫java程序，更要好好利用內存的有限資源，避免浪費。

C. 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中的每個元素不是相同對象。
簡言之， 淺克隆只復制本對象，深克隆除了本對象，其兒子、孫子、....都要克隆。
以上純手敲，有錯請包涵。

D. java 對象 克隆

這是裡面的一段（非完整的例子）：
public class Snake implements Cloneable {

...........................

public Object clone() {
Object o = null;
try {
o = super.clone();
} catch (CloneNotSupportedException e) {}
return o;

}
書上一段給你看看，希望有幫助把。。
當製作實例變數的一個引用時，原始實例變數和副本實力變數在內存中引用的均是同一個存儲空間，這就意味著但對其中一個實例變數操作時就會影響到這個對象的副本。例如下面的程序代碼。在執行時將會看到所畫的兩條線重合在一起，都是改變後的LineFigure1。
LineFigure lineFigure1 = new LineFigure();
LineFigure lineFigure2 = lineFigure1;
lineFigure1.draw(g);
…code for changing lineFigure1
lineFigure2.draw(g);
如果想讓LineFigure2成為一個新的對象，就要用到Clone( )方法。Clone的後對象和原對象的存儲空間不同，改變其中一個並不會對另一個產生任何影響。例如下面代碼所示：
…………….
LineFigure2 = lineFigure1.clone();
…………….
如果LineFigure2中沒有對其他對象的引用，事情就到此結束了，但LineFigure類中的實例變數StartPoint和EndPoint都是一個對象，即使簡單地實現了對LineFigure1地Clone，可LineFigure1和LineFigure2的StartPoint和EndPoint實例變數引用的是同一個變數，要想完全的實現將LineFigure2和LineFigure1分離開，就要實現Cloneable介面，並重寫Clone方法。Cloneable介面是Java提供的少數幾個標簽化介面之一。平常所說的標簽化介面就是不提供任何方法的介面。在圖形白板程序中，也用到了Cloneable介面，例如LineFigure類中的代碼：
public class LineFigure extends Figure implements Cloneable{
public Object clone(){
LineFigure lineFigure = new LineFigure();
lineFigure.startPoint = (Point)startPoint.clone();
lineFigure.endPoint = (Point)endPoint.clone();
lineFigure.firstDraw = firstDraw;
return lineFigure;
}
………………..
}
這樣一來，LineFigure1和LineFigure2所引用的對象就沒有任何的重合。對其中任何一個進行修改而不影響另一個的應用。

E. 如何克隆Java對象

Java中的對象涉及使用引用類型，沒有直接的方法可將一個對象的內容復制到一個新對象中。將一個引用分配給另一個引用只會給相同對象建立另一個引用。因此，Java對所有引用類型使用一個特殊的clone()方法，為對象復制自身提供一個標準的機制。以下是你需要了解和克隆Java對象有關的細節。為何建立一個本地拷貝？給一個對象建立本地拷貝的原因很可能是由於你計劃修改該對象，並且你不想修改方法調用者的對象。如果你確定你需要一個本地拷貝，你可以使用Object類的clone()方法來執行這項操作。clone()方法被定義為受保護方法，但你必須在你希望克隆的所有子類中重新公開定義它。例如，標准庫類ArrayList忽略clone()，但你可以這樣為ArrayList調用clone()方法：import java.util.*;class MyInt {private int i;public MyInt(int ii) { i = ii; }public void increment() { i++; }public String toString() {return Integer.toString(i);}}public class Test {public static void main(String[] args) {ArrayList al = new ArrayList();for(int i = 0; i < 10; i++ )al.add(new MyInt(i));ArrayList al1 = (ArrayList)al.clone();// Increment all al1』s elements:for(Iterator e = al1.iterator(); e.hasNext(); ) ((MyInt)e.next()).increment();}}clone()方法生成一個Object，它必須重新轉變為適當的類型。這個例子說明ArrayList的clone()方法如何不能自動克隆ArrayList包含的每一個對象?原有ArrayList和克隆後的ArrayList是相同對象的別名。這種情況通常叫做淺拷貝，因為它僅僅復制一個對象的「表面」部分。實際的對象由這個「表面」，引用指向的所有對象，以及那些對象指向的所有對象等構成。這往往被稱作「對象網路」。下一頁>>

F. Java中請問將一個對象賦值給另一個同類對象，這兩個對象是否指向同一堆內存

是的。

對象是引用類型的，所以如果把一個對象賦值給另一個變數，它實際上只是把內存地址賦值了。也就是說，如果對象都是同一地址，那麼改變該地址的值，另外一個同地址的對象也會改變。

首先可以使用構造器的參數區別開兩個對象，如果要直接賦值而不互相影響，那麼可以使用clone（淺復制、深復制包含內部引用等）方法如Person newPerson=（Person）oldPerson.clone();這樣新舊對象是2個對象而不是共用一個地址的2個對象。

堆和棧

內存管理在Java語言中是JVM自動操作的，當JVM發現某些對象不再需要的時候，就會對該對象佔用的內存進行重分配（釋放）操作，而且使得分配出來的內存能夠提供給所需要的對象。

在一些編程語言裡面，內存管理是一個程序的職責，但是書寫過C++的程序員很清楚，如果該程序需要自己來書寫很有可能引起很嚴重的錯誤或者說不可預料的程序行為，最終大部分開發時間都花在了調試這種程序以及修復相關錯誤上。

以上內容參考：網路-java內存模型

G. java如何深度一個object

java本身好像沒有提供這個方法的吧，只有你自己重新創建一個對象，然後賦值給這個對象。
iamge的復制可以用BufferedImage的方法：
public WritableRaster Data(WritableRaster outRaster)計算 BufferedImage 的一個任意矩形區域，並將其復制到指定的 WritableRaster。要計算的區域由指定 WritableRaster 的邊界確定。指定 WritableRaster 必須具有與此圖像兼容的 SampleModel。如果 outRaster 為 null，則創建一個合適的 WritableRaster。
不過還有一個簡單的辦法，就是創建一個一樣大小和一樣類型的BufferedImage,然後把要復制的圖畫上去，這兩個圖片就是一樣的了。

H. Java 如何復制對象

可以使用clone來實現，clone用於為引用類型的復制
1.使用clone方法的類必須先實現Cloneable介面，不然clone方法會直接返回CloneNotSupportedException不支持克隆的異常
2、實現Cloneable介面的類應該使用公共方法重寫 Object.clone（它是受保護的）。某個對象實現了此介面就克隆它是不可能的。即使 clone 方法是反射性調用的，也無法保證它將獲得成功。
3、在Java.lang.Object類中克隆方法是這么定義的：
protected Object clone()
throws CloneNotSupportedException
創建並返回此對象的一個副本。表明是一個受保護的方法，同一個包中可見。

I. Java中，復制一個對象，有什麼好的方法

使用Java的反射機制實現：為了能更好的區分，寫成了兩個類，可以運行下面的代碼看看效果
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Test {
public static void main(String[] args) throws Exception {
Customer1 c1 = new Customer1();
c1.setName("c1");
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
c1.setList(list);
Map<String,String> map = new HashMap<String, String>();
map.put("map1", "map1");
map.put("map2", "map2");
c1.setMap(map);
Customer2 c2 = new Customer2();
//
Class c = c1.getClass();
Class class2 = c2.getClass();
Field fields[] = c.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
String fieldName = field.getName();
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String getMethodName = "get" + firstLetter + fieldName.substring(1);
String setMethodName = "set" + firstLetter + fieldName.substring(1);
Method getMethod = c.getMethod(getMethodName, new Class[] {});
Method setMethod = class2.getMethod(setMethodName,
new Class[] { field.getType() });
Object value = getMethod.invoke(c1, new Object[] {});
setMethod.invoke(c2, new Object[] { value });
}
System.out.println(c2.getName());
System.out.println(c2.getList());
System.out.println(c2.getMap());
}
}
class Customer1 {
private String name;
private List<String> list;
private Map<String, String> map;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
}
class Customer2 {
private String name;
private List<String> list;
private Map<String, String> map;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
}

J. java 代碼實現對象的拷貝

package com.teven.comefromnet;

/**
* Name:C.java
* Founction:
* Created:2011-9-15
* @author :teven
*/
public class CloneTest {

static class A implements Cloneable{
int i=1;

@Override
protected A clone() throws CloneNotSupportedException {

return (A)super.clone();
}

}
static class B extends A{
int j=2;

@Override
protected B clone() throws CloneNotSupportedException {

return (B)super.clone();
}

}
static class C extends B{
int k=3;

@Override
protected C clone() throws CloneNotSupportedException {

return (C)super.clone();
}

}

public static void main(String[] args) throws CloneNotSupportedException {
A a = new CloneTest.A();
A aa = (A) a.clone();
System.out.println("before clone a.i = "+ a.i+">> after clone aa.i=" +aa.i);

B b = new CloneTest.B();
B bb= (B) b.clone();
System.out.println("before clone b.j = "+ b.j+">> after clone bb.j=" +bb.j);

C c = new CloneTest.C();
C cc= (C) c.clone();
System.out.println("before clone c.k = "+ c.k+">> after clone cc.k=" +cc.k);

}

}