Java中的对象克隆

在 Java 语言中，我们说两个对象是否相等通常有两层含义：

1。对象的内容是否相等，通常使用到对象的 equals(Object o) 函数；
2。引用的地址是否相同，使用运算符 ＝＝ 比较即可。

当两个对象通过赋值符号 = 赋值时，表明这两个对象指向了内存中同一个地址，所以改变其中一个对象的内容，也就间接地改变了另一个对象的内容。有时候，我们需要从一个已经存在的对象重新拷贝一份出来，并且不仅这两个对象内容相等，在内存中存在两个独立的存储地址，互不影响，这时，就需要用到 Java 中的克隆机制。

Cloneable
通过 Cloneable 接口可以很轻松地实现 Java 对象的克隆，只需要 implements Cloneable 并实现 Object 的 clone() 方法即可。注意这里对象实现的是 Object 类的 clone() 方法，因为 Cloneable 是一个空接口：

public interface Cloneable {}

从源码注释中可以看出，需要实现 Object 类中的 clone() 方法（注意：clone() 函数是一个 native 方法，同时抛出了一个异常）：

 protected native Object clone() throws CloneNotSupportedException;

测试代码如下（注意：我们在 User 对象中重写了 equals() 函数）：

public class User implements Cloneable {    private String username;    private String password;    public User(String username, String password) {        super();        this.username = username;        this.password = password;    }    public String getUsername() {        return username;    }    public void setUsername(String username) {        this.username = username;    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone();    }    @Override    public int hashCode() {        final int prime = 31;        int result = 1;        result = prime * result                + ((password == null) ? 0 : password.hashCode());        result = prime * result                + ((username == null) ? 0 : username.hashCode());        return result;    }    @Override    public boolean equals(Object obj) {        User user = (User)obj;        if(username.equals(user.username) && password.equals(user.password)) {            return true;        }        return false;    }    public static void main(String[] args) throws CloneNotSupportedException {        User userOne , userTwo, userThree;        userOne = new User("username", "password");        userTwo = userOne;        userThree = (User) userOne.clone();        System.out.println(userTwo == userOne); //true        System.out.println(userTwo.equals(userOne));//true        System.out.println(userThree == userOne);//false        System.out.println(userThree.equals(userOne));//true    }}

测试结果显示，通过 clone() 函数，我们成功地从 userOne 对象中克隆出了一份独立的 userThree 对象。
浅克隆与深克隆
谈此之前，我们先看一个例子，定义一个名为 Company 的类，并添加一个类型为 User 的成员变量：

public class Company implements Cloneable {    private User user;    private String address;    public Company(User user, String address) {        super();        this.user = user;        this.address = address;    }    public User getUser() {        return user;    }    public void setUser(User user) {        this.user = user;    }    public String getAddress() {        return address;    }    public void setAddress(String address) {        this.address = address;    }    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone();    }//  protected Object clone() throws CloneNotSupportedException {//      Company company = (Company) super.clone();//       company.user = (User) company.getUser().clone();//       return company;//  }    @Override     public boolean equals(Object obj) {        Company company = (Company)obj;        if(user.equals(company.getUser()) && address.equals(company.getAddress())) {            return true;        }         return false;    }    public static void main(String[] args) throws CloneNotSupportedException {        Company companyOne, companyTwo, companyThree;        companyOne = new Company(new User("username", "password"), "上海市普陀区");        companyTwo = companyOne;        companyThree = (Company)companyOne.clone();        System.out.println(companyOne == companyTwo);        System.out.println(companyOne.equals(companyTwo));        System.out.println(companyOne == companyThree);        System.out.println(companyOne.equals(companyThree));        System.out.println(companyThree.getUser() == companyOne.getUser());        System.out.println(companyThree.getUser().equals(companyOne.getUser()));    }}

问题来了，companyThree 与 companyOne 中的 User 是同一个对象！也就是说 companyThree 只是克隆了 companyOne 的基本数据类型的数据，而对于引用类型的数据没有进行深度的克隆。也就是俗称的浅克隆。

浅克隆：顾名思义，就是很表层的克隆，只克隆对象自身的引用地址；
深克隆：也称“N层克隆”，克隆对象自身以及对象所包含的引用类型对象的引用地址。

这里需要注意的是，对于基本数据类型（primitive）和使用常量池方式创建的String 类型，都会针对原值克隆，所以不存在引用地址一说。当然不包括他们对应的包装类。

所以使用深克隆就可以解决上述 Company 对象克隆过后两个 user 对象的引用地址相同的问题。我们修改一下 Company 类的 clone() 函数：

    protected Object clone() throws CloneNotSupportedException {        Company company = (Company) super.clone();         company.user = (User) company.getUser().clone();         return company;    }

再运行测试代码，就能得到 companyThree.getUser()==companyOne.getUser() 为 false 的结果了。
Serializable实现

通过上述介绍，我们知道，实现一个对象的克隆，需要如下几步：
1。对象所在的类实现 Cloneable 接口；
2。重写 clone() 函数，如果包涵引用类型的成员变量，需要使用深克隆。
如果对象不包含引用类型成员或者数量少的话，使用 Cloneable 接口还能接受，但当对象包含多个引用类型的成员，同时这些成员又包含了引用类型的成员，那层层克隆岂不是相当繁琐，并且维护不便？所以，这里介绍一种更加方便的实现方式，使用 ObjectOutputStream 和 ObjectOutputStream 来实现对象的序列化和反序列化

import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.Serializable;public class People implements Serializable {    private String name;    private int age;    public People() {        this.name = "wangwenhao";        this.age = 26;    }    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 static void main(String[] args) throws IOException, ClassNotFoundException {        People people = new People();        ObjectOutputStream oos = null;        ObjectInputStream ois = null;        FileOutputStream fos = new FileOutputStream("people.out");        oos = new ObjectOutputStream(fos);        oos.writeObject(people);        oos.close();        People anotherPeople = null;        FileInputStream fis = new FileInputStream("people.out");        ois = new ObjectInputStream(fis);        anotherPeople = (People) ois.readObject();        System.out.println("name: " + anotherPeople.getName() + "  " + " age:  " + anotherPeople.getAge());        ois.close();    }}

序列化一组对象，因为数组属于引用数据类型， 所以可以直接使用Object类型接收。下面是代码演示：

import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.OutputStream;import java.io.Serializable;class Person implements Serializable {    private String name;    private int age;    public Person(String name, int age) {        super();        this.name = name;        this.age = age;    }    @Override    public String toString() {        return "Person [name=" + name + ", age=" + age + "]";    }}public class SerDemo {    public static void main(String[] args) throws IOException, ClassNotFoundException {        Person per[] = {new Person("张三", 30), new Person("李四", 31), new Person("王五", 32)};        ser(per);        Object o[] = dser();        for(int i = 0; i < o.length; i++) {            Person p = (Person)o[i];            System.out.println(p);        }    }    public static void ser(Object obj[]) throws IOException {        File f = new File("D:" + File.separator + "test.txt");        OutputStream out = new FileOutputStream(f);        ObjectOutputStream oos = new ObjectOutputStream(out);        oos.writeObject(obj);        oos.close();    }    public static Object[] dser() throws IOException, ClassNotFoundException {        File f = new File("D:" + File.separator + "test.txt");        InputStream input = new FileInputStream(f);        ObjectInputStream ois = new ObjectInputStream(input);        Object obj[] = (Object[]) ois.readObject();        ois.close();        return obj;    }}

参考：http://www.tuicool.com/articles/rYbA3y