Java clone、浅复制、深复制、复制构造函数

在java中的对象重复利用通常有两种渠道：复制引用、克隆，不管何种方法，它们都是为了减少对象重复创建和赋值操作，一定程度上提高效率。这里就有关对象复用的几种方式和关系进行探讨。

共识

java中的对象分为两派：值类型和引用类型，这是因为他们的传递方式，一个是值传递，一个是引用传递。

对于值类型，因为是值传递，所以在使用值类型的时候无须考虑引用类型存在一些问题，如：equals，hashcode，nullpoint，而在这里关键无须考虑的问题是：复制问题。诸如y = 1;x=y,y=2这些happend-befored，值类型的值是不受过去和将来影响的。

而对于引用类型就没这么轻松了，大家也有目共睹，于是在复制问题上，就有了题目中列出的方式。

Clone

User u1 = new User（“”，“”，“”，“”）

User u1 = new User（“”，“”，“”，“”）

像上面这种拙劣的对象创建方式，是我们不希望看到的。JAVA提供了对象克隆方法，这个是Object类的本地方法，利用克隆可以快速高效的复制一个对象而无需重新创建：

public class User implements Cloneable{
	String name = "origin";
	
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

@Test
	public void testClone() throws CloneNotSupportedException {
		User u1 = new User();
		User u2 = (User) u1.clone();
		System.out.println(u1.hashCode());
		System.out.println(u1.name);
		
		u1.name = "origin2";
		System.out.println(u2.hashCode());
		System.out.println(u2.name);
		
	}

输出：

1607460018

origin

48612937

origin

可以看出，克隆会创建出一个新的对象，对象的成员具有原始对象的信息，并且成员都是新的内存分配。要使用clone方法，必需实现Cloneable接口，该接口意义和serializable类似，然后重写Object的clone方法并调用super的本地方法。

浅复制

不过这看起来似乎挺美好的背后，并不是如你所想的那样，我们给user加一个复合引用类型的Inner：

public class User implements Cloneable{
	String name = "origin";
	Inner inner;
	
	public User() {
		inner = new Inner();
		inner.name = "inner-origin";
	}

这个Inner类同样持有一些引用类型的成员：

public class Inner{
	String name;
}

@Test
	public void testClone() throws CloneNotSupportedException {
		User u1 = new User();
		User u2 = (User) u1.clone();
		
		System.out.println(u1.hashCode());
		System.out.println(u1.name);
		System.out.println(u1.inner.name);
		
		u1.name = "origin2";
		u1.inner.name = "innerorigin2";
		
		System.out.println(u2.hashCode());
		System.out.println(u2.name);
		System.out.println(u2.inner.name);

输出：

1607460018
origin
inner-origin
48612937
origin

innerorigin2

显然：如果成员是另一个复合类型的引用，那么这个成员还是受到happend-before影响，也就是说，使用clone只能做到表面功夫，无法对更深层的引用进行内存层面上的复制，因此，这种复制方式被称为：浅复制。

深复制

深复制应该就是相对于浅复制，实现一个对象由外到内的全面克隆。如何做到深复制，java不像C语言那样可以通过operator操作来进行值拷贝，因此没有办法做到绝对意义上的深复制，可以说是没有这个概念。那么，这里说的深复制是在一定前提下进行的，就可以达到深复制的效果。

深复制方式1：对象序列化反序列化

public class User implements Cloneable,Serializable{
	String name = "origin";
	Inner inner;
	
	public User() {
		inner = new Inner();
		inner.name = "inner-origin";
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
	
	public Object deepCopy(User u) throws IOException, ClassNotFoundException {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(out);
		oos.writeObject(u);
		InputStream in = new ByteArrayInputStream(out.toByteArray());
		ObjectInputStream ois = new ObjectInputStream(in);
		return ois.readObject();
		
	}

同时，要求引用类型的成员也要实现序列化接口：

public class Inner implements Serializable{
	String name;
}

public class TestClone {
	
	@Test
	public void testClone() throws CloneNotSupportedException, ClassNotFoundException, IOException {
		User u1 = new User();
		User u2 = (User) u1.clone();
		User u3 = (User) u1.deepCopy(u1);
		
		u1.name = "origin2";
		u1.inner.name = "innerorigin2";
		
		System.out.println(u1.hashCode());
		System.out.println(u1.inner.hashCode());
		System.out.println(u1.name);
		System.out.println(u1.inner.name);
		
//		System.out.println(u2.hashCode());
//		System.out.println(u2.name);
//		System.out.println(u2.inner.name);
		
		System.out.println(u3.hashCode());
		System.out.println(u3.inner.hashCode());
		System.out.println(u3.name);
		System.out.println(u3.inner.name);
	}

输出：

1607460018
1811075214
origin2
innerorigin2
48612937
325333723
origin
inner-origin

可以看到深复制的目的已经达成，因为通过序列化和反序列化将分配新的内存创建对象和成员，所以这种做法是有效的，然而效率却很低下，毕竟不能称为复制，只是一种婉转曲折的传输方式，比较取巧，但是一些ORM框架仍然不得不采用这种做法，导致效率低下。

深复制方式2：复制函数

观察这两个User的构造函数有什么不同？

	public User(String name,Inner inner) {
		this.name = name;
		this.inner = inner;
	}
	
	public User(User user) {
		this.name = user.name;
		this.inner = new Inner();
		inner.name = user.inner.name;
	}

第一个是有参的构造函数，第二个是用于复制的构造函数，所以也称为复制构造函数，用于从一个相同类型的对象中复制成员变量。这个例子就不测试了，相信你也能看出，其实就是多了一道工序来创建新的成员变量inner，而不是引用原来的inner对象，效率自然会比序列化和反序列化要高，只不过深度有限，不能保证复制深度范围外的对象深复制。如果你确定成员中的引用类型也能保证（或不需要关心）不变性，那么就可以通这种方式做一个不完全的深复制，在效率和深度上做一个平衡。

效率

下面做了一个简单的测试，可以看出浅复制和深复制的差距：

	@Test
	public void testCopy() throws CloneNotSupportedException {
		for(int i=0;i<100000;i++) {
			User u1 = new User();
			User u2 = (User) u1.clone();	
		}
	}
	
	@Test
	public void testDeepCopy() throws CloneNotSupportedException, ClassNotFoundException, IOException {
		for(int i=0;i<100000;i++) {
			User u1 = new User();
			User u3 = (User) u1.deepCopy(u1);
		}
	}
	
	@Test
	public void testDeepCopyByConstructor() {
		for(int i=0;i<100000;i++) {
			User u1 = new User();
			User u3 = new User(u1);
		}
	}