java 深复制与浅复制

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

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

实现深复制的关键：以流的形式读写对象的二进制表示

测试代码如下：

Clone：

package com.study.clone;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Clone implements Cloneable, Serializable {
	
	private Child child;
	
	public Clone() {}
	
	public Clone(Child child) {
		this.child = child;
	}

	/**
	 * 实现对象浅复制
	 * 浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的
	 * @param o
	 * @return
	 * @throws CloneNotSupportedException
	 */
	public Object lightClone() throws CloneNotSupportedException {
		Object newObject = null;
		newObject = super.clone();
		return newObject;
	}
	
	/**
	 * 实现对象深复制
	 * 深复制: 将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的
	 * @param o
	 * @return
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 */
	public Object deepClone() throws IOException, ClassNotFoundException {
		Object newObject = null;
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(bos);
		// 将对象写到bos流中
		oos.writeObject(this);
		ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
		ObjectInputStream ois = new ObjectInputStream(bis);
		newObject = ois.readObject();
		return newObject;
	}
	
	public Child getChild() {
		return child;
	}
	
	public void setChild(Child child) {
		this.child = child;
	}
	
	public static void main(String[] args) {
		Clone clone0 = new Clone(new Child("child0"));
		Child child0 = clone0.getChild();
		// 测试浅复制
		try {
			Clone clone1 = (Clone)clone0.lightClone();
			Child child1 = clone1.getChild();
			if(child0 == child1) {
				System.out.println("浅复制");
			}
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		
		// 测试深复制
		try {
			Clone clone2 = (Clone) clone0.deepClone();
			Child child2 = clone2.getChild();
			if(child0 != child2) {
				System.out.println("深复制");
			}
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

}

Child：

package com.study.clone;

import java.io.Serializable;

public class Child implements Serializable {
	
	private String name;
	
	public Child() {}
	
	public Child(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}

}

结果输出为：

浅复制
深复制