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

}

}