Part6：Java中的克隆

@
***

Example01：Java对象的假克隆

对象的克隆是Java中的一项高级技术，获得与其相同的对象。

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

运行结果：

代码实现：

public class Employee {
private String name;
private int age;
//省略set()和get()方法

@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public static void main(String[] args) {
System.out.println("-----克隆之前：--------");
Employee employee1 = new Employee();
employee1.setName("hyn");
employee1.setAge(20);
System.out.println("员工1的信息：\n"+employee1);
System.out.println("-----克隆之后：--------");
Employee employee2 = employee1; //将employee1赋值给employee2
employee2.setName("azw");
employee2.setAge(21);
System.out.println("员工1的信息：\n"+employee1);
System.out.println("员工2的信息：\n"+employee2);
}
}

Example02：Java对象的浅克隆

??在克隆对象时，如果对象的成员变量是基本数据类型，则使用浅克隆即可完成。如果对象的成员变量包括可变引用类型，则需要深克隆。

运行结果：

代码实现：

//Address.java
public class Address {
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;
}

//省略set()和get()方法

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("国家："+state+"，");
sb.append("省："+province+"，");
sb.append("市："+city);
return sb.toString();
}
}
//Employee.java
public class Employee implements Cloneable{
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;
}
//省略set()和get()方法

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("姓名："+name+"，");
sb.append("年龄："+age+"，");
sb.append("\n地址："+address);
return sb.toString();
}

@Override
public Employee clone() throws CloneNotSupportedException { //实现浅克隆
Employee employee = (Employee) super.clone();
return employee;
}
}

测试代码：

class Test {
public static void main(String[] args) throws CloneNotSupportedException {
System.out.println("*****克隆之前：******");
Address address = new Address("中国", "湖北", "武汉");
Employee employee1 = new Employee("azw", 20, address);
System.out.println("员工1的信息：\n" + employee1); //employee1的信息
System.out.println("*****克隆之后：******");
Employee employee2 = employee1.clone(); //使用克隆创建Employee2
employee2.getAddress().setState("中国"); //修改地址
employee2.getAddress().setProvince("黑龙江");
employee2.getAddress().setCity("哈尔滨");
employee2.setName("hyn");
employee2.setAge(21);
System.out.println("员工1的信息：\n" + employee1);
System.out.println("员工2的信息：\n" + employee2);
}
}

如果引用类型是不可变的，如String类对象，则不必进行深克隆。
***

Example03：Java对象的深克隆

如果类的成员变量中包括可变引用类型，则需进行深克隆。

运行结果：

代码实现：

//Address.java
public class Address implements Cloneable{
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;
}
//省略set()和get()方法

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("国家："+state+"，");
sb.append("省："+province+"，");
sb.append("市："+city);
return sb.toString();
}
//---------------------------
@Override
public Address clone() throws CloneNotSupportedException {
//Address类中的域不是基本类型就是不可变类型，所以可以直接使用浅克隆
Address address = (Address) super.clone();
return address;
}
//---------------------------
}
//Employee.java
public class Employee implements Cloneable{
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;
}
//省略set()和get()方法

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("姓名："+name+"，");
sb.append("年龄："+age+"，");
sb.append("\n地址："+address);
return sb.toString();
}
@Override
public Employee clone() throws CloneNotSupportedException { //实现深克隆
Employee employee = (Employee) super.clone();
//---------------------------------
employee.address = address.clone();
//---------------------------------
return employee;
}
}
//测试代码同Example02测试代码.

要点：通常情况下，需要用到克隆对象时都需要使用深克隆。
***

Example04：序列化与对象克隆

??如果类的成员变量比较复杂，例如使用了多个可变的引用类型，使用clone()方法是非常麻烦的，所以可以考虑序列化的方式完成克隆。
运行结果：

代码实现：

import java.io.Serializable;
public class Employee implements Serializable {
//同Example04中Employee.java的代码
}
public class Address implements Serializable {
//同Example04中Assress.java的代码
}

测试代码：

class Test {
public static void main(String[] args) throws IOException, ClassNotFoundException {
System.out.println("*****序列化之前：******");
Address address = new Address("中国", "湖北", "武汉");
Employee employee1 = new Employee("azw", 20, address);
System.out.println("员工1的信息：\n" + employee1); //employee1的信息
System.out.println("*****序列化之后：******");
Employee employee2 = null;
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("E:\\employee.txt"));
out.writeObject(employee1); //将对象写入到本地文件中
ObjectInputStream in = new ObjectInputStream(new FileInputStream("E:\\employee.txt"));
employee2 = (Employee)in.readObject(); //从本地文件中读取对象
if (employee2 != null) {
employee2.getAddress().setState("中国"); //修改地址
employee2.getAddress().setProvince("黑龙江");
employee2.getAddress().setCity("哈尔滨");
employee2.setName("hyn");
employee2.setAge(21);
System.out.println("员工1的信息：\n" + employee1);
System.out.println("员工2的信息：\n" + employee2);
}
}
}

要点：进行序列化的类需要实现Serializable接口，该接口中并没有定义任何方法，是一个标识接口。如果类中有可变的引用类型成员变量，则该变量需要实现Serializable接口。本实例采用将对象写入本地文件的方式完成序列化。
***

Example05：深克隆和序列化的效率比较

通过使用这两种方式克隆100000个对象，并输出花费的时间来比较这两种方法的效率。

运行结果：

代码实现：

import java.io.Serializable;
public class Employee implements Cloneable,Serializable {
private String name;
private int age;
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("姓名："+name+"，");
sb.append("年龄："+age+"，");
return sb.toString();
}
@Override
public Employee clone() throws CloneNotSupportedException { //使用父类的clone()方法实现深克隆
Employee employee = (Employee) super.clone();
return employee;
}
}
测试代码：
import java.io.*;
import java.util.ArrayList;
import java.util.List;
class Test {
public static void main(String[] args) throws IOException, ClassNotFoundException, CloneNotSupportedException {
List<Employee> employees = new ArrayList<Employee>(); //创建列表保存对象
Employee employee = new Employee("azw", 20); //创建对象
long currentTime = System.currentTimeMillis(); //获得当前系统时间
//使用克隆方式获得对象
for (int i = 0;i<100000;i++){
employees.add(employee.clone());
}
System.out.println("克隆花费的时间："+(System.currentTimeMillis()-currentTime)+"毫秒");
currentTime = System.currentTimeMillis(); //获得当前系统时间
for (int i = 0;i<100000;i++){
ByteArrayOutputStream bout = new ByteArrayOutputStream(); //创建字节数组输出流
ObjectOutputStream out = new ObjectOutputStream(bout); //创建对象输出流
out.writeObject(employee); //将对象写入到输出流中
//获得字节输出流内容
ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
ObjectInputStream in = new ObjectInputStream(bin); //创建对象输入流
employees.add((Employee) in.readObject()); //读取对象
}
System.out.println("序列化花费的时间："+(System.currentTimeMillis()-currentTime)+"毫秒");
}
}

要点：使用ByteArrayOutputStream和ByteArrayInputStream可以将对象保存在内存中，这样就不必产生一个本地文件来完成序列化的功能。
***

假克隆、浅克隆和深克隆的应用范围

假克隆基本数据类型

浅克隆基本数据类型、不可变引用类型

深克隆可变引用类型