Java的深克隆与浅克隆

1.Java的基本数据类型和引用数据类型

基本数据类型包括byte、int、char、long、float、double、boolean和short八种基本数据类型 创建的对象在Java虚拟机栈中，

引用数据类型创建对象的时候会创建两个对象，一个在栈中，一般称作 ‘‘引用“，另一个存放在Java堆中。

2.浅克隆与深克隆

浅克隆的外在表现是：对象的基础类型对象相同，引用对象相同，包括存放在堆里的对象。也就是说所有的对其他对象的引用仍然指向原来的对象。

深克隆的外在表现是：复制前后的对象是相等的，也就是说引用的对象是相等的，而不是同一块Java堆中的内存。

对于对象来说相同和相等是充分不必要条件，相同一定相等，相等确往往可能不相同。

浅克隆是发生在栈中的拷贝，深克隆包括堆中对象的引用对象的拷贝。

3.Java对象的clone研究

<span style="font-family:Courier New;">package com.dusk.bean;

public class Student implements Cloneable{
	private String id;
	private Address address;
	public Student(){
	}
	public Student(String id){
		this.id=id;
	}
	public String getId() {
		return id;
	}

	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}

	public void sayHello(){
		System.out.println("hello,everyone!");
	}
	@Override
	public Student clone() throws CloneNotSupportedException {
		return (Student) super.clone();
	}

}</span>

Address.java

<span style="font-family:Courier New;">package com.dusk.bean;

public class Address {
<span style="white-space:pre">	</span>private String address;
<span style="white-space:pre">	</span>public String getAddress() {
<span style="white-space:pre">		</span>return address;
<span style="white-space:pre">	</span>}

<span style="white-space:pre">	</span>public void setAddress(String address) {
<span style="white-space:pre">		</span>this.address = address;
<span style="white-space:pre">	</span>}</span>

}

Client.java

<span style="font-family:Courier New;">package com.dusk;

import org.junit.Test;

import com.dusk.bean.Student;

public class Client {
	@Test
	public void test() throws Exception {
		Student stu1=new Student("1");
		Student stu2=stu1.clone();
		System.out.println(stu1==stu2);
		System.out.println(stu1.getAddress()==stu2.getAddress());
	}
}</span>

运行结果:

<span style="font-family:Courier New;">false
true
</span>

结论: Object提供的clone方法默认是浅克隆操作，对Student对象中的address没有进行clone操作。

4.同理对System.arraycopy进行验证，上代码：

<span style="font-family:Courier New;">package com.dusk;

import org.junit.Test;

import com.dusk.bean.Student;

public class Test5 {
	@Test
	public void test() {
		Student[] arr1=new Student[]{new Student("1"),new Student("2"),new Student("3"),new Student("4")};
		Student[] arr2=new Student[4];
		System.arraycopy(arr1, 0, arr2, 0, 4);
		for(int i=0;i<arr2.length;i++){
			System.out.println(arr1[i]==arr2[i]);
		}
	}

}

</span>

运行结果：

<span style="font-family:Courier New;">true
true
true
true</span>

发现，System.arraycopy提供的也是浅克隆。

如果实现深克隆怎么办？ 答案就是自己重写clone方法。

例如:

<span style="font-family:Courier New;"><span style="white-space:pre">	</span>@Override
	public Student clone() throws CloneNotSupportedException {
		Student stu=new Student();
		stu.setId(this.id);
		stu.setAddress(new Address());
		return stu;
	}</span>

结果肯定是：

<span style="font-family:Courier New;">false
false</span>

是不是到此为止了？怎么可能，

如果我们把Address也实现了Cloneable怎么样？

Address.java变身为

<span style="font-family:Courier New;">package com.dusk.bean;

public class Address implements Cloneable{

	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}

}</span>

继续调用3中的场景, 结果是：

<span style="font-family:Courier New;">false
true
</span>

尽然不是我预想的递归调用，看来如果自己的对象引用比较深的情况下做深克隆，自能自己退下自己的苦果了。

只能这样了吗？

看我必杀技，ObjectOutputStream和ObjectInputStream，祭法宝：

<span style="font-family:Courier New;">package com.dusk;

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

import org.junit.Test;

import com.dusk.bean.Address;
import com.dusk.bean.Student;

public class Client{
	@Test
	public void test() throws CloneNotSupportedException {
		Student stu1=new Student("1");
		Address add = new Address();
		stu1.setAddress(add);
		Student stu2=(Student) deepCopy(stu1);
		System.out.println(stu1==stu2);
		System.out.println(stu1.getAddress()==stu2.getAddress());
	}

	private Object deepCopy(Object obj){
		//将对象写到流里
		try {
		 ByteArrayOutputStream bo=new ByteArrayOutputStream();
		 ObjectOutputStream oo;
			oo = new ObjectOutputStream(bo);
		 oo.writeObject(obj);
		 //从流里读出来
		 ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
		 ObjectInputStream oi=new ObjectInputStream(bi);
		 return(oi.readObject());
		} catch (Exception e) {
			e.printStackTrace();
		}
		return obj;
	}
}</span>

结果:

<span style="font-family:Courier New;">false
false</span>

完美的解决了对象多次套用的深克隆问题。

只要思想不滑坡，办法总比困难多！