Java中的堆与栈之克隆篇

       Java将内存空间分成两块，即栈和堆。在栈中保存基本类型和引用变量，在堆中保存对象。对于栈中的变量在使用完后会立即被回收，这样就可以继续创建其他的变量。而对于堆中的对象，是由虚拟机进行管理的，因此即使该对象已经不再使用，该内存空间只会在一个不确定的时间被回收。

一、假克隆

       Java中，对于基本类型可以使用“=”来进行克隆，此时两个变量除了相等没有任何关系。而对于引用类型却不能简单地使用“=”进行克隆。这与Java的内存空间使用有关。对于引用变量而言，使用“=”将修改引用，而不是复制堆中的对象。此时两个引用变量将指向同一对象。因此，如果一个变量对其进行修改则会改变另一个变量。

二、浅克隆

       Java中任何一个类都是Object类的直接或间接子类。如果类没有超类，则它默认继承自Object类。在Object类中，实现了很多有用的方法。当克隆对象时，需要使用clone(）方法，该方法的声明如下：

protected Object clone() throws CloneNotSupportedException

       需要注意的是，该方法时一个受保护的方法，通常需要重写该方法并将访问权限限定符改成public。该方法将类中各个域进行复制，如果对于引用类型的域，这种操作就会有问题，因此称作浅克隆。提供克隆功能的类需要实现Cloneable接口，否则使用clone()方法时会抛出CloneNotSupportedException。

注：对于类中的每个域，如果只包含基本类型和不可变的引用类型，或对象在其生命周期内不会发生变化，则可以使用浅克隆来复制对象。通常情况下，需要使用深克隆。

三、深克隆

当需要克隆对象时，需要使用clone方法，该方法的声明如下：

protected Object clone() throws CloneNotSupportedException

在默认情况下，该方法实现了浅克隆功能。为了支持可变的引用类型，需要在重写该方法时，将引用类型也进行克隆。这需要引用类型也重写clone方法。提供克隆功能的类需要实现Cloneable接口，否则使用clone方法时会抛出CloneNotSupportedException。

注：通常情况下，克隆对象时都需要使用深克隆。但是需要注意的是，如果引用类型中还有可变的引用类型域，则该域也需要进行克隆。

四、序列化与对象克隆

      对于深克隆而言，如果类有许多引用类型的域，那么重写clone方法依次复制各个域是非常麻烦的。如果引用类型的域也是由引用类型组成的，则应该考虑使用序列化的方法实现深克隆。

      序列化可以将任意对象写入到流中。根据流的类型不同，可以将对象写入到文件中。也可以将对象写入到字节数组中。克隆对象时一般不需要先进行保存，因此将使用字节数组。在写入完成后，再将其读出就可以实现克隆。使用序列化可以不用考虑引用类型的域，编写clone()方法相对简单，但是要求引用类型也实现Serializable接口。

注：如果使用了API中的类并且该类并没有实现Serializable接口，则该域需要使用transient修饰。

代码如下：

package com.trouble.clone;

import java.io.Serializable;

public class Address implements Serializable {

	private static final long serialVersionUID = 1L;
	private String state;
	private String province;
	private String city;

	public Address(String state, String province, String city) {
		this.state = state;
		this.province = province;
		this.city = city;
	}

	public String getState() {
		return state;
	}

	public void setState(String state) {
		this.state = state;
	}

	public String getProvince() {
		return province;
	}

	public void setProvince(String province) {
		this.province = province;
	}

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		StringBuilder sb = new StringBuilder();
		sb.append("国家：" + state + ",");
		sb.append("省：" + province + ",");
		sb.append("市：" + city);
		return sb.toString();
	}
}

package com.trouble.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 Employee implements Serializable, Cloneable {

	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	private Address address;

	public Employee(String name, int age, Address address) {
		this.name = name;
		this.age = age;
		this.address = address;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		StringBuilder sb = new StringBuilder();
		sb.append("姓名：" + name + ",");
		sb.append("年龄：" + age + "\n");
		sb.append("地址：" + address);
		return sb.toString();
	}

	@Override
	protected Employee clone() {
		Employee employee = null;
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try {
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.writeObject(this);
			oos.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
		try {
			ObjectInputStream ois = new ObjectInputStream(bais);
			employee = (Employee) ois.readObject();
			ois.close();
		} catch (IOException | ClassNotFoundException e) {
			e.printStackTrace();
		}
		return employee;
	}

}

package com.trouble.clone;

public class Test {

	public static void main(String[] args){
		Address address = new Address("中国","吉林","长春");
		Employee employee1 = new Employee("明月科技",12,address);
		System.out.println(employee1);
		Employee employee2 = employee1.clone();
		System.out.println(employee2);
		employee2.setAge(14);
		employee2.getAddress().setProvince("四川");
		employee2.getAddress().setCity("成都");
		System.out.println(employee1);
		System.out.println(employee2);
	}
}

注：首先，对于任何一个序列化的对象，都要求其实现Serializable接口。其次，如果该类的域中有引用类型，则要求该引用类型也实现Serializable接口，以此类推，最后序列化方式实现克隆会比直接克隆各个引用类型域慢，这一点在效率优先时要考虑。

总结：如果类的各个域是基本类型或不可变类型，则可以使用浅克隆，否则需要使用深克隆。如果类的域比较复杂，可以使用序列化的方式实现，否则应该使用复制域的方式实现深克隆。

五、transisent关键字

       transient关键字用来防止序列化域。如果一个引用类型被transient修饰，则其反序列化的结果是null。如果一个基本类型被transient修饰，则其反序列化的结果是0。如果域的引用类型是不可序列化的类，则也应该使用transient修饰，它在序列化时会被直接跳过。

注：transient只能用来修饰域，不能用来修饰方法。当使用类库中的可变类作为引用类型域时，如果引用类型不能被序列化，即没有实现Serializable接口，而又需要序列化该类时，则应用transient修饰该域。否则在反序列化时会引起错误。