关于Java对象复制(Clone、深度Clone以及序列化与反序列化的��?

JonahChen — Sun, 02 Dec 2007 07:06:00 GMT

我们在编码过�E�经�怼��到��一个对象传递给另一个对象，java中对于基本型变量

采用的是��g��递，而对于对象比如bean传递时采用的是应用传递也��是地址传递，

而很多时候对于对象传递我们也希望能够象��g��递一��P��使得传递之前和之后�?/div>

不同的内存地址�Q�在�q�种情况下我们一般采用以下两�U�情��c�?/div>

1 对象克隆

在实际编�E�过�E�中�Q�我们常常要遇到�q�种情况�Q�有一个对象A�Q�在某一时刻A中已�l�包含了一些有效��|��此时可能会需要一个和A完全相同新对�? B�Q��ƈ且此后对B��M��改动都不会媄响到A中的��|��也就是说�Q�A与B是两个独立的对象�Q�但B的初始值是由A对象��定的。在Java语言中，用简单的赋��D��? 是不能满��U�需求的。要满��q�种需求虽然有很多途径�Q�但实现clone�Q�）�Ҏ��是其中最��单，也是最高效的手�D�c�?

Java的所有类都默认��承java.lang.Object�c�，在java.lang.Object�c�M��有一个方法clone()�? JDK API的说明文��解释这个方法将�q�回Object对象的一个拷贝。要说明的有两点�Q�一是拷贝对象返回的是一个新对象�Q�而不是一个引用。二是拷贝对象与�? new操作�W�返回的新对象的区别��是�q�个拯��已经包含了一些原来对象的信息�Q�而不是对象的初始信息�?

怎样应用clone()�Ҏ��Q?/font>

一个很典型的调用clone()代码如下�Q?

class CloneClass implements Cloneable{

            public int aInt;

            public Object clone(){

            CloneClass o = null;

            try{

            o = (CloneClass)super.clone();

            }catch(CloneNotSupportedException e){

            e.printStackTrace();

            }

            return o;

            }

            �?br />

有三个值得注意的地方，一是希望能实现clone功能的CloneClass�c�d��C��Cloneable接口�Q�这个接口属于java.lang包， java.lang包已�l�被�~�省的导入类中，所以不需要写成java.lang.Cloneable。另一个值得��h��意的是重载了clone()�Ҏ��。最后在clone()�Ҏ��中调用了super.clone()�Q�这也意味着无论clone�cȝ��l�承�l�构是什么样的，super.clone()直接或间接调用了java.lang.Object�cȝ��clone()�Ҏ��。下面再详细的解释一下这几点�?

应该说第三点是最重要的，仔细观察一下Object�cȝ��clone()一个native�Ҏ��Q�native�Ҏ��的效率一般来说都是远高于 java中的非native�Ҏ��。这也解释了��Z��么要用Object中clone()�Ҏ��而不是先new一个类�Q�然后把原始对象中的信息赋到新对象中�Q�虽然这也实��C��clone功能。对于第二点�Q�也要观察Object�c�M��的clone()�q�是一个protected属性的�Ҏ��。这也意味着如果要应�? clone()�Ҏ��Q�必��ȝ��承Object�c�，在Java中所有的�c�L��~�省�l�承Object�cȝ��Q�也��׃��用关心这点了。然后重载clone()�Ҏ��。还�? 一点要考虑的是��Z��让其它类能调用这个clone�cȝ��clone()�Ҏ��Q�重载之后要把clone()�Ҏ��的属性设�|��ؓpublic�?

那么clone�c�Mؓ什么还要实现Cloneable接口呢？�E�微注意一下，Cloneable接口是不包含��M��Ҏ��的！其实�q�个接口仅仅是一个标志，而且�q�个标志也仅仅是针对Object�c�M��clone()�Ҏ��的，如果clone�c�L��有实现Cloneable接口�Q��ƈ调用了Object�? clone()�Ҏ��Q�也��是调用了super.Clone()�Ҏ��Q�，那么Object的clone()�Ҏ��׃��抛出 CloneNotSupportedException异常�?

什么是影子clone�Q?/font>

下面的例子包含三个类UnCloneA�Q�CloneB�Q�CloneMain。CloneB�c�d��含了一个UnCloneA的实例和一个int �c�d��变量�Q��ƈ且重载clone()�Ҏ��。CloneMain�c�d��始化UnCloneA�cȝ��一个实例b1�Q�然后调用clone()�Ҏ��生成了一个b1的拷�? b2。最后考察一下b1和b2的输出：

package clone;

            class UnCloneA {

            private int i;

            public UnCloneA(int ii) { i = ii; }

            public void doubleValue() { i *= 2; }

            public String toString() {

            return Integer.toString(i);

            }

            }

            class CloneB implements Cloneable{

            public int aInt;

            public UnCloneA unCA = new UnCloneA(111);

            public Object clone(){

            CloneB o = null;

            try{

            o = (CloneB)super.clone();

            }catch(CloneNotSupportedException e){

            e.printStackTrace();

            }

            return o;

            }

            }

            public class CloneMain {

            public static void main(String[] a){

            CloneB b1 = new CloneB();

            b1.aInt = 11;

            System.out.println("before clone,b1.aInt = "+ b1.aInt);

            System.out.println("before clone,b1.unCA = "+ b1.unCA);

            

            CloneB b2 = (CloneB)b1.clone();

            b2.aInt = 22;

            b2.unCA.doubleValue();

            System.out.println("=================================");

            System.out.println("after clone,b1.aInt = "+ b1.aInt);

            System.out.println("after clone,b1.unCA = "+ b1.unCA);

            System.out.println("=================================");

            System.out.println("after clone,b2.aInt = "+ b2.aInt);

            System.out.println("after clone,b2.unCA = "+ b2.unCA);

            }

            }

            

            

            /** RUN RESULT:

            before clone,b1.aInt = 11

            before clone,b1.unCA = 111

            =================================

            after clone,b1.aInt = 11

            after clone,b1.unCA = 222

            =================================

            after clone,b2.aInt = 22

            after clone,b2.unCA = 222

            */

输出的结果说明int�c�d��的变量aInt和UnCloneA的实例对象unCA的clone�l�果不一��_��int�c�d��是真正的被clone了，因�ؓ�? 变了b2中的aInt变量�Q�对b1的aInt没有产生影响�Q�也��是��_��b2.aInt与b1.aInt已经占据了不同的内存�I�间�Q�b2.aInt�? b1.aInt的一个真正拷贝。相反，对b2.unCA的改变同时改变了b1.unCA�Q�很明显�Q�b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用�Q�从中可以看出，调用Object�c�M��clone()�Ҏ��产生的效果是�Q�先在内存中开辟一块和原始对象一��L��I�间�Q�然后原��h��贝原始对象中的内宏V��对基本数据�c�d��Q�这��L��操作是没有问题的�Q�但寚w��基本�c�d��变量�Q�我们知道它们保存的仅仅是对象的引用�Q�这也导致clone后的非基本类型变量和原始�? 象中相应的变量指向的是同一个对象�?

大多时候，�q�种clone的结果往往不是我们所希望的结果，�q�种clone也被�U�Cؓ"影子clone"。要惌��b2.unCA指向与b2.unCA不同的对象，而且b2.unCA中还要包含b1.unCA中的信息作�ؓ初始信息�Q�就要实现深度clone�?

怎么�q�行深度clone�Q?/font>

把上面的例子�Ҏ��深度clone很简单，需要两个改变：一是让UnCloneA�c�M��实现和CloneB�c�M��L��clone功能�Q�实�? Cloneable接口�Q�重载clone()�Ҏ��Q�。二是在CloneB的clone()�Ҏ��中加入一句o.unCA = (UnCloneA)unCA.clone();

�E�序如下�Q?

package clone.ext;

            class UnCloneA implements Cloneable{

            private int i;

            public UnCloneA(int ii) { i = ii; }

            public void doubleValue() { i *= 2; }

            public String toString() {

            return Integer.toString(i);

            }

            public Object clone(){

            UnCloneA o = null;

            try{

            o = (UnCloneA)super.clone();

            }catch(CloneNotSupportedException e){

            e.printStackTrace();

            }

            return o;

            }

            }

            class CloneB implements Cloneable{

            public int aInt;

            public UnCloneA unCA = new UnCloneA(111);

            public Object clone(){

            CloneB o = null;

            try{

            o = (CloneB)super.clone();

            }catch(CloneNotSupportedException e){

            e.printStackTrace();

            }

            o.unCA = (UnCloneA)unCA.clone();

            return o;

            }

            }

            public class CloneMain {

            public static void main(String[] a){

            CloneB b1 = new CloneB();

            b1.aInt = 11;

            System.out.println("before clone,b1.aInt = "+ b1.aInt);

            System.out.println("before clone,b1.unCA = "+ b1.unCA);

            

            CloneB b2 = (CloneB)b1.clone();

            b2.aInt = 22;

            b2.unCA.doubleValue();

            System.out.println("=================================");

            System.out.println("after clone,b1.aInt = "+ b1.aInt);

            System.out.println("after clone,b1.unCA = "+ b1.unCA);

            System.out.println("=================================");

            System.out.println("after clone,b2.aInt = "+ b2.aInt);

            System.out.println("after clone,b2.unCA = "+ b2.unCA);

            }

            }

            

            /** RUN RESULT:

            before clone,b1.aInt = 11

            before clone,b1.unCA = 111

            =================================

            after clone,b1.aInt = 11

            after clone,b1.unCA = 111

            =================================

            after clone,b2.aInt = 22

            after clone,b2.unCA = 222

            */

可以看出�Q�现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例�Q��? 且在CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的��|��在这里，b1.i = b2.i = 11�?

要知道不是所有的�c�都能实现深度clone的。例如，如果把上面的CloneB�c�M��的UnCloneA�c�d��变量�Ҏ�� StringBuffer�c�d��Q�看一下JDK API中关于StringBuffer的说明，StringBuffer没有重蝲clone()�Ҏ��Q�更��Z��重的是StringBuffer�q�是一�? final�c�，�q�也是说我们也不能用�l�承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer�c�d��对象或和 StringBuffer�怼��cȝ��对象�Q�我们有两种选择�Q�要么只能实现媄子clone�Q�要么就在类的clone()�Ҏ��中加一句（假设�? SringBuffer对象�Q�而且变量名仍是unCA�Q�： o.unCA = new StringBuffer(unCA.toString()); //原来的是�Q�o.unCA = (UnCloneA)unCA.clone();

�q�要知道的是除了基本数据�c�d��能自动实现深度clone以外�Q�String对象是一个例外，它clone后的表现好象也实��C��深度clone�Q�虽然这只是一个假象，但却大大方便了我们的�~�程�?

通过以上我们可以看出在某些情况下�Q�我们可以利用clone�Ҏ��来实现对象只见的复制�Q�但�? 于比较复杂的对象�Q�比如对象中包含其他对象�Q�其他对象又包含别的对象.....�Q�这��h��们必��进行层层深度clone�Q�每个对象需要实�? cloneable接口�Q�比较麻烦，那就�l�箋学习下一个序列化�Ҏ��?/font>

2 对象序列�?/strong>

所谓对象序列化��是��对象的状态�{换成字节��，以后可以通过�q�些值再生成相同状态的对象。这个过�E�也可以通过�|�络实现�Q�可以先在Windows机器上创��Z��个对象，对其序列化，然后通过�|�络发给一台Unix机器�Q�然后在那里准确无误地重�?#8220;装配”。是不是很神奇�?

也许你会��_��只了解一点点�Q�但从来没有接触�q�，其实未必如此。RMI、Socket、JMS、EJB你总该用过一�U�吧�Q�彼此�ؓ什么能够传递Java对象�Q�当焉��是对象序列化机制的功功�?

�W�一�ơ��用Java的对象序列化是做某项目，当时要求把几��非常复杂的�?JTree)及相应的数据保存下来�Q�就是我们常用的保存功能�Q�，以便下次�q�行�E�序时可以��l�上�ơ的操作�?

那时XML技术在�|�上非常的热�Q�而且功能也强大，再加上树的结构本来就和XML存储数据的格式很像。作��Z��对新技术比较有兴趣的我当然�? 惛_��试一下。不�q�经�q�仔�l�分析，发现如果采用XML保存数据�Q�后果真是难以想象：哪棵树的哪个节点被展开、展开到第几��、节点当前的属性是什么。真是不�? 该用A、B、C�q�是�?�?�?来表�C��?

�q�好�Q�发��C��Java的对象序列化机制�Q�问题迎刃而解�Q�只需��单的��每��|��的根节点序列化保存到��盘上，下次再通过反序列化后的根节点就可以��L��的构造出和原来一模一��L��树来�?

其实保存数据�Q�尤其是复杂数据的保存正是对象序列化的典型应用。最�q�另一个项目就遇到了需要对非常复杂的数据进行存取，通过使用对象的序列化�Q�问题同样化难�ؓ��?

对象的序列化�q�有另一个容易被大家忽略的功能就是对象复�Ӟ��Clone�Q�，Java中通过Clone机制可以复制大部分的对象�Q�但是众所�? 知，Clone有深层Clone和浅层Clone,如果你的对象非常非常复杂�Q�假设有�?00层的Collection�Q�夸张了点）�Q�如果你惛_��现深�? Clone�Q�真是不敢想象，如果使用序列化，不会��过10行代码就可以解决�?

�q�有��是Swing�l��g�Q�如果你有两个很象很象（或是一模一��P��的比较难以构造的Swing�l��g�Q�你该怎么办，也许你想��C��Clone�Q�但是偏偏Java的Swing�l��g没有提供Clone�Ҏ��。别急，使用序列化，6行代码搞定：

ByteArrayOutputStream
byteOut = new ByteArrayOutputStream();
ObjectOutputStream out
= new ObjectOutputStream(byteOut);
out.writeObject(combo);

ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
ObjectInputStream in
=new ObjectInputStream(byteIn);
JComboBox comb2 = (JComboBox)in.readObject();

虽然Java的序列化非常��单、强大，但是要用好，�q�有很多地方需要注意。比如曾�l�序列化了一个对象，可由于某�U�原因，该类做了一点点改动�Q�然后重新被�~�译�Q�那么这时反序列化刚才的对象�Q�将会出现异常�?

你可以通过��d��serialVersionUID属性来解决�q�个问题。如果你的类是个单态（Singleton�Q�类�Q�是否允许用户通过序列化机制复制该�c�，如果不允�怽�需要�}慎对待该�cȝ��实现�?nbsp;

    /**
     * Clone Object
     * @param obj
     * @return
     * @throws Exception
     */
    private Object cloneObject(Object obj) throws Exception{
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(obj);

        ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
        ObjectInputStream in =new ObjectInputStream(byteIn);

        return in.readObject();
    }

参考资料：

1.http://www-128.ibm.com/developerworks/cn/java/l-jpointer/index.html

2.http://www.softexam.cn/eschool/details.asp?id=10930

JonahChen 2007-12-02 15:06 发表评论

久久综合九色综合欧美98,国产精品久久久久久久久久99,国产视频二区在线观看

关于Java对象复制(Clone、深度Clone以及序列化与反序列化的���?

关于Java对象复制(Clone、深度Clone以及序列化与反序列化的��?