对象的深度复制

首先什么是深度复制？什么又是浅复制？

百度告诉我--------------->

浅复制：将一个对象复制后，基本类型都会重新创建，而引用类型指向的还是原对象所指的引用；

深复制：讲一个对象复制后，不论是基本类型还是引用类型都是重新创建的。

下面看我们的深度复制方法

package everyworkdayprogramming._2015_3_03;

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;

/**
 * 
 * 在使用对象流对对象进行深度复制的时候对象必须实现Cloneable，Serializable接口
 * 前者标明对象是可以被复制的，后者则是为了能够满足我们使用对象流对对象进行深度复制
 * 
 * */
public class CopySource implements Cloneable, Serializable {

	/**
	 * @Fields serialVersionUID : 对象的序列化唯一标识
	 */
	private static final long serialVersionUID = -3446490540857082055L;
	/* 定义连个变量，不是基本类型，而且都实现了Serializable 接口 */
	private String string;

	private SerializableObject serializableObject;

	public String getString() {
		return string;
	}

	public void setString(String string) {
		this.string = string;
	}

	public SerializableObject getSerializableObject() {
		return serializableObject;
	}

	public void setSerializableObject(SerializableObject serializableObject) {
		this.serializableObject = serializableObject;
	}

	/* 浅复制 */
	public Object clone() throws CloneNotSupportedException {
		/* 浅复制直接调用父类的clone方法就可以进行复制 */
		CopySource copySource = (CopySource) super.clone();
		return copySource;
	}

	/* 深复制 */
	public Object deepClone() throws IOException, ClassNotFoundException {

		/* 写入当前对象的二进制流 */
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		ObjectOutputStream oout = new ObjectOutputStream(out);
		oout.writeObject(this);

		/* 读出二进制流产生的新对象 */
		ObjectInputStream oin = new ObjectInputStream(new ByteArrayInputStream(
				out.toByteArray()));
		/* 这样我们的深度复制工作就完成了；所有对象都是新的 */
		return oin.readObject();
	}

}

/**
 * 
 * 该类包含在CopySource中，用于测试是否对类的实例中的该对象进行了深度复制
 * 
 * */
class SerializableObject implements Serializable {

	/**
	 * @Fields serialVersionUID : 对象的序列化唯一标识
	 */
	private static final long serialVersionUID = 6357352492173107445L;

	/* 一下的属性用于测试对象中的对象中的对象是否还可以被深度复制 */
	/* 基本类型 */
	private int x = 1;
	/* 非基本类型 */
	private Date date;
	private SerializableObject1 serializableObject1;

	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public Date getDate() {
		return date;
	}

	public void setDate(Date date) {
		this.date = date;
	}

	public SerializableObject1 getSerializableObject1() {
		return serializableObject1;
	}

	public void setSerializableObject1(SerializableObject1 serializableObject1) {
		this.serializableObject1 = serializableObject1;
	}

}

/**
 * 
 * 对象中的对象中的对象,当然也实现了Serializable
 * 
 * */
class SerializableObject1 implements Serializable {

	/**
	 * @Fields serialVersionUID : 对象的序列化唯一标识
	 */
	private static final long serialVersionUID = 1L;

}

测试方法：

package everyworkdayprogramming._2015_3_03;

import java.io.IOException;
import java.util.Date;

public class Test {
	public static void main(String[] args) {
		/* 创建要被复制的对象，并初始化相应属性 */
		CopySource copy = new CopySource();
		copy.setSerializableObject(new SerializableObject());
		copy.setString("123");
		copy.getSerializableObject().setX(2);
		copy.getSerializableObject().setDate(new Date());
		copy.getSerializableObject().setSerializableObject1(
				new SerializableObject1());

		try {
			/* 浅复制copy 到 copy1 */
			CopySource copy1 = (CopySource) copy.clone();
			/* 深复制copy 到 copy2 */
			CopySource copy2 = (CopySource) copy.deepClone();

			/* 判断SerialiableObject在浅复制和深复制后是否与原对象中的相等 */
			System.out
					.println("----------------------------------------------------------判断SerialiableObject在浅复制和深复制后是否与原对象中的相等");
			System.out.println(copy.getSerializableObject() == copy1
					.getSerializableObject());
			System.out.println(copy.getSerializableObject() == copy2
					.getSerializableObject());
			/* 判断string在浅复制和深复制后是否与原对象的相等 */
			System.out
					.println("----------------------------------------------------------判断string在浅复制和深复制后是否与原对象的相等");
			System.out.println(copy.getString() == copy1.getString());
			System.out.println(copy.getString() == copy2.getString());
			/* 判断SerializableObject中的DATE在浅复制和深复制后是否与原对象相等 */
			System.out
					.println("----------------------------------------------------------判断SerializableObject中的DATE在浅复制和深复制后是否与原对象相等 ");
			System.out.println(copy.getSerializableObject().getDate() == copy1
					.getSerializableObject().getDate());
			System.out.println(copy.getSerializableObject().getDate() == copy2
					.getSerializableObject().getDate());
			/* 判断SerializableObject中的SerializableObject1在浅复制和深复制后是否与原对象相等 */
			System.out
					.println("----------------------------------------------------------判断SerializableObject中的SerializableObject1在浅复制和深复制后是否与原对象相等");
			System.out.println(copy.getSerializableObject()
					.getSerializableObject1() == copy1.getSerializableObject()
					.getSerializableObject1());
			System.out.println(copy.getSerializableObject()
					.getSerializableObject1() == copy2.getSerializableObject()
					.getSerializableObject1());
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

测试结果

转载于:https://www.cnblogs.com/qzmpc/p/6339561.html