Java 实现深度复制

写在前面：

        什么是深度复制？在Java里面，在创建一个对象，我们通常会有一个引用指向该对象，当我们通过引用变量改变对象的值（属性）时，引用是不变的，变的是内存里面的那块内存，即引用所指向的对象。一般情况下，我们将该引用赋给另一个引用变量或者作为参数传递时，传递的也只是引用，即将引用指向“复制”了一份给另一个引用变量，随后该引用变量也指向同一个对象，内存里面并没有创建一个新的对象。在某些情况下，我们需要“真正复制”对象，创建一份已知对象的copy，而不仅仅“复制”引用，用作备份也好，其他操作也好。

        那么，该如何实现？

        先说下思路：首先将对象序列化到流里，然后再反序列化，从流里读取出来即可。

        下面上代码：

package com.yo.java;

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.ArrayList;
import java.util.List;

/**
 * Java 实现深度复制
 * @author Yo
 *
 */
public class DeepCopy implements Serializable{
	int i;
	/**
	 * @param args
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws ClassNotFoundException, IOException {
		demo1();
		demo2();
	}
	/**
	 * 深度复制，实参类必须实现Serializable接口
	 * @param o
	 * @return
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
	public static Object deepCopy(Object o) throws IOException, ClassNotFoundException {
//		//先序列化，写入到流里
		ByteArrayOutputStream bo = new ByteArrayOutputStream();
		ObjectOutputStream oo = new ObjectOutputStream(bo);
		oo.writeObject(o);
		//然后反序列化，从流里读取出来，即完成复制
		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
		ObjectInputStream oi = new ObjectInputStream(bi);
		return oi.readObject();
	}
	
	/**
	 * 引用传递与深度复制
	 * @throws ClassNotFoundException
	 * @throws IOException
	 */
	public static void demo1() throws ClassNotFoundException, IOException {
		System.out.println("===========未使用深度复制=========");
		DeepCopy dc1 = new DeepCopy();
		dc1.i = 1;//初始化dc1里i的值
		DeepCopy dc2 = dc1;
		dc1.i = 2;//改变dc1里i的值
		System.out.println("dc1 : " + dc1.i);
		System.out.println("dc2(引用传递) : " + dc2.i);
		System.out.println("===========使用深度复制=========");
		DeepCopy dc3 = new DeepCopy();
		dc3.i = 1;//初始化dc3里i的值
		DeepCopy dc4 = (DeepCopy)deepCopy(dc3);
		dc3.i = 2;//改变dc3里i的值
		System.out.println("dc3 : " + dc3.i);
		System.out.println("dc4(深度复制) : " + dc4.i);
	}
	/**
	 * 集合的值复制与深度复制
	 * @throws ClassNotFoundException
	 * @throws IOException
	 */
	public static void demo2() throws ClassNotFoundException, IOException {
		System.out.println("===========未使用深度复制=========");
		//创建DeepCopy对象，并初始化i的值，添加到list1集合
		DeepCopy dc = new DeepCopy();
		dc.i = 1;//初始化dc1里i的值
		List<DeepCopy> list1 = new ArrayList<DeepCopy>();
		list1.add(dc);
		//未使用深度复制
		List<DeepCopy> list2 = new ArrayList<DeepCopy>(list1);//这里与使用Collections.copy(dest, src)结果一样
		//改变list1中元素的值
		for(DeepCopy d1 : list1) {
			//改变dc1里i的值
			d1.i = 2;
		}
		//遍历list
		for(DeepCopy d1 : list1) {
			System.out.println("list1 : " + d1.i);
		}
		//遍历list2
		for(DeepCopy d2 : list2) {
			System.out.println("list2(复制） : " + d2.i);
		}
		System.out.println("===========使用深度复制后=========");
		DeepCopy dc3 = new DeepCopy();
		dc3.i = 1;//初始化dc3里i的值
		List<DeepCopy> list3 = new ArrayList<DeepCopy>();
		list3.add(dc3);
		List<DeepCopy> list4 = (List<DeepCopy>) deepCopy(list3); 
		for(DeepCopy d : list3) {
			//改变dc3里i的值
			d.i = 2;
		}
		for(DeepCopy d3 : list3) {
			System.out.println("list3 : " + d3.i);
		}
		for(DeepCopy d4 : list4) {
			System.out.println("list4(深度复制）: " + d4.i);
		}
	}
}

        以上运行结果如下(实测）：

	===========未使用深度复制=========
	dc1 : 2
	dc2(引用传递) : 2
	===========使用深度复制=========
	dc3 : 2
	dc4(深度复制) : 1
	===========未使用深度复制=========
	list1 : 2
	list2(复制） : 2
	===========使用深度复制后=========
	list3 : 2
	list4(深度复制）: 1

        由此可见，当仅仅只是引用传递或者根据对象的值创建新的值，仅能称为“浅复制”，当原对象的属性发生改变时，根据上面方式创建的新对象的属性也会随之改变；而如果采用深度复制，那是真正的copy了一份新的对象，新对象的与原对象不存在任何关联，原对象的属性发生改变不会影响新对象，就如同copy的意义一样

如上，如有不妥，如能指出，非常感谢