java 深克隆与浅克隆

大家知道，对象是互相引用的，即对象中可能包含了另一个对象的引用，举例如：有一个Order对象，Order对象中又包含了LineItems对象，然后LineItems对象又包含了Item对象。


好了，现在我有一个Order对象order1,它包含了一个LineItems对象items，这表示的是有一个订单order1，订单的内容是items。


好的，现在有另一个客户想要一份订单，内容跟order1完全一样，那么在系统的逻辑层我们怎么做呢？很简单，order2=order1.clone(). 我们知道clone方法是在内存中生成一个新的对象，而不是只得到原对象的引用。这时候，有人说话了：“哦，明白了我们对order2的成员变量进行修改，是不会影响order1的。” 很可惜，这句话只对了一半。


假设order类有一个成员变量name，当然改变order2.name不会影响order1.name，因为他们在不同的内存区域。但是如果改变 order1.items呢？很遗憾，简单地使用order1.clone，是会影响到order2.items的。原因很简单，就是因为clone方法默认的是浅克隆，即不会克隆对象引用的对象，而只是简单地复制这个引用。所以在上例中，items对象在内存中只有一个，order1和order2都指向它，任何一个对象对它的修改都会影响另一个对象。


那相对浅克隆，深克隆自然就是会克隆对象引用的对象了。也就是说，在上例中，改变order1.items并不会影响order2.items了。因为内存中有两个一样的items。


如果实现深克隆？

一个方法自然是重写clone方法，添加如order.items=(LineItems)items.clone()的语句，也就是人为地添加对引用对象的复制。这个方法的缺点是如果引用对象有很多，或者说引用套引用很多重，那么太麻烦了。业界常用的方法是使用串行化然后反串行化的方法来实现深克隆。由于串行化后，对象写到流中，所有引用的对象都包含进来了，所以反串行化后，对等于生成了一个完全克隆的对象。绝！

这个方法的要求是对象（包括被引用对象）必须事先了Serializable接口，否则就要用transient关键字将其排除在复制过程中。

克隆就是复制一个对象的复本.但一个对象中可能有基本数据类型,如:int,long,float 等,也同时含有非基本数据类型如(数组,集合等)
被克隆得到的对象基本类型的值修改了,原对象的值不会改变.这种适合shadow clone(浅克隆).

但如果你要改变一个非基本类型的值时,原对象的值却改变了,.比如一个数组,内存中只copy他的地址,而这个地址指向的值并没有copy,当clone时,两个地址指向了一个值,这样一旦这个值改变了,原来的值当然也变了,因为他们共用一个值.,这就必须得用深克隆(deep clone)

以下举个例子,说明以上情况：

被克隆类:ShadowClone.java

class ShallowClone implements Cloneable {
    public int a;
    public int[] b;
    
    public ShallowClone() {
        a = 5;
        b = new int[] {1, 2, 3, 4, 5};
    }
    
    // 浅克隆，对于克隆后的对象，只能保证对基础类型成员的修改不会影响原对象的相应成员
    // 对类类型和数组类型的成员，只是拷贝了对象的地址，因此对克隆后对象的这些类型成员
    // 进行修改会影响原对象
    @Override
    public Object clone() {
        ShallowClone sc = null;
        try {
            sc = (ShallowClone)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return sc;
    }
}

测试类：

public class DeepAndShallowClone {
    public static void main(String[] args) throws Exception {
        // shallow clone
        ShallowClone sc = new ShallowClone();
        ShallowClone scCopy = (ShallowClone)sc.clone();
        
        
        System.out.println("Shallow Copy");
        System.out.println("--Before clone");
        System.out.println("sc.a=" + sc.a);
        System.out.println("sc.b=" + sc.b[0]);
        
        scCopy.a = 1;
        scCopy.b[0] = 10;
        System.out.println("--After clone");
        System.out.println("sc.a=" + sc.a);
        System.out.println("sc.b=" + sc.b[0]);
        System.out.println("scCopy.a=" + scCopy.a);
        System.out.println("scCopy.b=" + scCopy.b[0]);
    }
}

结果如下：

ShallowCopy
--Beforeclone
sc.a=5
sc.b=1
--Afterclone
sc.a=5
sc.b=10
scCopy.a=1
scCopy.b=10

问题出现了,修改了克隆后的对象scCopy.b[0]的值,但sc.b[0]的值也改变了,与scCopy.b[0]的值相等.
以下针对浅克隆得出结论:基本类型是可以被克隆的,但引用类型只是copy地址,并没有copy这个地址指向的对象的值,这使得两个地址指向同一值,修改其中一个,当然另一个也就变了.
由此可见,浅克隆只适合克隆基本类型,对于引用类型就不能实现克隆了.

那如何实现克隆引用对象呢,以下提供一种方法. 用序列化与反序列化实现深克隆(deep copy)

被克隆对象.DeepClone.java

class DeepClone implements Serializable {
    private static final long serialVersionUID = 1L;
    public int a;
    public int[] b;
    
    public DeepClone() {
        a = 10;
        b = new int[] {6, 7, 8, 9, 10};
    }
    
    // 使用ObjectInput(Output)Stream和ByteArrayInput(Output)Stream实现深克隆
    public Object deepClone() throws IOException, ClassNotFoundException {
        DeepClone dc = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(this);
        oos.close();
        
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream bis = new ObjectInputStream(bais);
        dc = (DeepClone)bis.readObject();
        return dc;
    }
}

测试类：

public class DeepAndShallowClone {
    public static void main(String[] args) throws Exception {
        DeepClone dc = new DeepClone();
        DeepClone dcCopy = (DeepClone)dc.deepClone();
        System.out.println("--Before clone");
        System.out.println("dc.a=" + dc.a);
        System.out.println("dc.b=" + dc.b[0]);
        dcCopy.a = 1;
        dcCopy.b[0] = 1;
        
        System.out.println("Shallow Copy");
        System.out.println("--After clone");
        System.out.println("dc.a=" + dc.a);
        System.out.println("dc.b=" + dc.b[0]);
        System.out.println("dcCopy.a=" + dcCopy.a);
        System.out.println("dcCopy.b=" + dcCopy.b[0]);
    }
}

结果如下：

--Beforeclone
dc.a=10
dc.b=6
ShallowCopy
--Afterclone
dc.a=10
dc.b=6
dcCopy.a=1
dcCopy.b=1

writeObject方法会将被克隆类的对象关系网都写出，这样就可以实现深克隆。当然，每个被克隆的成员类型必须实现Serializable接口