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接口


发布了4 篇原创文章 · 获赞 0 · 访问量 5175
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览