Java深复制浅复制解析.md

2017-09-08 本文已影响167人 mance

Java 克隆概念

Java克隆分为深克隆和浅克隆两种类型。

浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
深复制（深克隆）被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。
下面两张图形象揭示了深克隆和浅克隆的区别。

clone1.jpg
clone.jpg

实现克隆的方式

1. 实现cloneable接口

所有类都默认继承了object类，object 类中定义有clone（）方法，返回类型：object，修饰符为protect ，子类可用。所以无法对类的变量直接使用clone方法（如：定义了某个类Student，声明变量aStudent并创建了对象，但无法使用aStudent.clone(）)。

protected native Object clone() throws CloneNotSupportedException;

Cloneable 只是一个标志接口而已，用来标志该类是否有克隆功能。

public interface Cloneable {

}

事实上，类 Object 的 clone() 方法首先会检查 this.getClass() 是否实现了 Cloneable 接口。
如果 this.getClass() 没有实现 Cloneable 接口， clone() 就会抛 CloneNotSupportedException 返回。否则就会创建一个类型为 this.getClass() 的对象 other ，并将 this 各 field 的值赋值给 other 的对应 field ，然后返回 other 。

实现clone（）的方法：要通过类中重写clone的方法，修饰符改为public。除此之外，还必须实现Cloneable接口，否则会抛出异常（）。Java类库中提供的一些类都可以直接使用clone()方法，是因为都默认实现了cloneable()接口。

clone()的默认实现

class Student implements Cloneable {
    String name = null;
    int number = 0;
    Date date;

    public Student(Date date, String name, int number) {
        this.date = date;
        this.name = name;
        this.number = number;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

测试代码：

public static void main(String[] args) throws CloneNotSupportedException {
    Student student = new Student(new Date(), "liyice", 0211007760);
    Student st = (Student) student.clone();
    System.out.println(student.name == st.name);
    System.out.println(student.number == st.number);
    System.out.println(student.date == st.date);

}

输出结果：

true
true
true

可以看出clone()方法默认的是浅克隆，date()对象并没有实现克隆，而是复制了引用。对clone()方法进行修改，即可实现深度克隆。

@Override
protected Object clone() throws CloneNotSupportedException {
    Student studentClone = (Student) super.clone();
    studentClone.date = (java.util.Date) this.date.clone();
    // 编译错误，String类没有实现clone()方法
    //studentClone.name = (String) this.name.clone();
    return studentClone;
}

输出结果为：

true
true
false

通过以上的实例可以发现，如果要实现深度克隆，需要自己在clone()方法内部添加实现方法，但是如果类的内部结构比较复杂，有较多的嵌套引用，那么实现起来肯呢个会比较麻烦。

2. 通过序列化与反序化数据流

使用序列化的方式实现深度克隆，要求所有的对象都要实现serializable，包括对象中包含的对象。如果没有实现了serializable接口且无法修改所有的类，则推荐使用第三种方式。

/**
* @param obj 要克隆的对象
* @param <T> 泛型
* @return 克隆的对象
* @throws Exception 如果没有实现seriablizable接口将会抛出异常
*/
public static <T> T copyImplSerializable(T obj) throws Exception {
   ByteArrayOutputStream baos = null;
   ObjectOutputStream oos = null;

   ByteArrayInputStream bais = null;
   ObjectInputStream ois = null;

   Object o;
   //如果子类没有继承该接口，这一步会报错
   try {
       baos = new ByteArrayOutputStream();
       oos = new ObjectOutputStream(baos);
       oos.writeObject(obj);
       bais = new ByteArrayInputStream(baos.toByteArray());
       ois = new ObjectInputStream(bais);

       o = ois.readObject();
       return (T) o;
   } catch (Exception e) {
       throw new Exception("对象中包含没有继承序列化的对象");
   } finally {
       try {
           baos.close();
           oos.close();
           bais.close();
           ois.close();
       } catch (Exception e2) {
           //这里报错不需要处理
       }
   }
}

对以上方法进行测试，

public static void main(String[] args) throws Exception {
    Student student = new Student(new Date(), "liyice", 0211007760);
    Student st = copyImplSerializable(student);
    System.out.println(Objects.equals(student.name, st.name));
    System.out.println(student.number == st.number);
    System.out.println(student.date == st.date);
}

输出结果为：

true
true
false

由此可见采用序列化为数据流的方式是深度克隆。

3. 通过序列化为json

由于fastjson在json解析中具有最快的性能，因此本例子采用fastjson对对象进行序列化与反序列化。

/**
 * @param obj 要克隆的对象
 * @param <T> 对象的类型
 * @return 克隆的对象
 */
public static <T> T copyByJson(T obj, Class c){
    return (T) JSON.parseObject(JSON.toJSONString(obj), c);
}

创建测试代码

public static void main(String[] args) throws Exception {
    Man man = new Man(27,new Date(),"liyice", "male");
    Man m = copyByJson(man, Man.class);
    System.out.println(man.getName() == m.getName());
    System.out.println(man.getSex() == m.getSex());
    System.out.println(man.getAge() == m.getAge());
    System.out.println(man.getDate() == m.getDate());
}

<b>@TODO
在测试过程中发现了一些问题，一是在序列化的时候要求Javabean中的每个成员变量必须具有set和get方法，不然无法进行序列化，二是要求javabean必须是public的，不然反序列化的时候会抛出异常，目前还不知道原因是什么，留待后面解决。</b>