java深克隆和浅克隆

克隆就是复制一个对象的复本.但一个对象中可能有基本数据类型,如: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 ]);
    }
}

结果如下：

Shallow Copy
-- Before clone
sc.a = 5
sc.b = 1
-- After clone
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 ]);
    }
}

　　结果如下：

-- Before clone
dc.a = 10
dc.b = 6
Shallow Copy
-- After clone
dc.a = 10
dc.b = 6
dcCopy.a = 1
dcCopy.b = 1

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