Java实例 Part6：Java中的克隆

• Part6：Java中的克隆
  • Example01：Java对象的假克隆
  • Example02：Java对象的浅克隆
  • Example03：Java对象的深克隆
  • Example04：序列化与对象克隆
  • Example05：深克隆和序列化的效率比较
  • 假克隆、浅克隆和深克隆的应用范围

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可以将对象保存在内存中，这样就不必产生一个本地文件来完成序列化的功能。
***

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

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

---