java對象的拷貝

Ⅰ java淺拷貝的對象兩個內向相等嗎

兩個對象內向相等。
java對象默認繼承java。long。Object類，裡麵包含clone方法。JDKAPI的說明文檔解釋這個方法將返回Object對象的一個拷貝。要說明的有兩點：一是拷貝對象是一個新對象，而不是一個引用。二是拷貝對象與用new操作符返回的新對象的區別就是這個拷貝已經包含了一些原來對象的信息，而不是對象的初始信息。
java中的基本數據類型判斷是否相等，直接使用==就行了，相等返回true，否則，返回false。

Ⅱ 如何克隆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是相同對象的別名。這種情況通常叫做淺拷貝，因為它僅僅復制一個對象的「表面」部分。實際的對象由這個「表面」，引用指向的所有對象，以及那些對象指向的所有對象等構成。這往往被稱作「對象網路」。下一頁>>

Ⅲ 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);

}

}

Ⅳ JAVA中對象具有類定義的所以變數的一份拷貝，這句話有什麼不對

java中的類對象沒有拷貝，只是一個指向原來對象空間的一個引用，如果想要新建的另外拷貝

Ⅳ java 拷貝對象工具類有哪些

其他普通類：：從beanInfo【每一個對象都有一個緩存的bean信息，包含屬性欄位等】取出name，然後把sourceClass和targetClass逐個拷貝

Ⅵ JAVA如何實現深拷貝

下面給你簡單介紹protected 域（或方法）實現過程思路：

protected 域（或方法）對本包內的所有類可見（當然包括子類），那麼，子類可以獲得訪超類受保護域（或方法）的權利，但是，若子類和超類不在同一個包下，就不能訪問超類對象的這個受保護域（或方法）。

淺拷貝與深拷貝

Object類對自己的具體子類的域一無所知，Object類的clone方法只是將各個域進行拷貝。數值或基本類型不會出現問題，但是，如果在對象中包含了引用對象，這些對象的內容沒有被自我復制，拷貝的結果也即是原始對象和拷貝對象引用著同一個引用對象（一般地，動詞「引用」可理解為「管理」，就是指向同一內存）。

淺拷貝滿足：

x.clone() != x為 true，

x.clone().getClass() == x.getClass()為true，

((x.clone().field1 ) == (x. field1))&& … &&((x.clone().fieldN )==(x. fieldN))也為 true 。

如果原始對象與淺拷貝對象共同引用（管理、指向）的引用對象是不可變的，將不會產生任何問題

如果原始對象管理的引用對象是可變的，就必須需重新定義clone方法，來實現深層次的拷貝。要對涉及的每一個類，判斷以下兩點：

默認的clone方法是否滿足需求。

默認的clone方法是否能通過調用可變引用對象的clone方法得到解決。

對涉及的每一個類，深拷貝要滿足：

x.clone() != x為 true，

x.clone().getClass() == x.getClass()為true，

x.clone().equals(x)也為 true ，當然equals方法是如此重寫過的。

Object類中的clone方法被聲明為protected，防止出現文章開頭所提到的，子類和超類不在同一個包下的情況，要聲明clone為public，來實現深拷貝

Ⅶ 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;
}
}

Ⅷ java對象值的

讓B成為A的子類，使用JAVA的反射機制，自己寫一個子類拷貝父類的屬性的函數，這樣無論父類有幾個屬性都可以不用修改代碼了。

參考一下：
http://jeffen2006.iteye.com/blog/319672

Ⅸ Java 如何復制對象

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