java 基础之深克隆浅克隆 博客分类： JAVA java序列反序列克隆

这段时间一直在看javabean的处理，可谓是博大精深，apache的beanutil由于用到的是反射机制，和cglib的beanutil速度差了好几百倍，这不是本节博客重点，在研究bean的拷贝的时候，顺便复习了一下java里的克隆技术，这里只做克隆部分记录
（下次分享一下另外一个高效率，高配置的beanutil工具来copyproperties，在googlecode上找到一个可以通过配置xml的元和目标的框架来进行copy属性的东东，希望通过努力我可以改成annotation版本）


浅克隆：
       简单值类型的拷贝，引用类型只是用了同一份，并没有copy一份新的，所以更改时候会有影响。

深克隆：
       把简单类型和复杂类型都拷贝一份，这样更改源或目标里的引用时不会印象另一端。

代码如下：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Locale;


public class DeepAndShallowClone {
public static void main(String[] args) throws Exception{
	System.out.println("-------浅克隆克隆---------");
	// 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] = 1;
    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]);
	
	System.out.println("-------深克隆---------");
	 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]);
}
}
class ShallowClone implements Cloneable {
    public int a;
    public int[] b;
    
    public ShallowClone() {
        a = 100;
        b = new int[] {100, 2, 3, 4, 5};
    }
    
    // 浅克隆，对于克隆后的对象，只能保证对基础类型成员的修改不会影响原对象的相应成员
    // 对类类型和数组类型的成员，只是拷贝了对象的地址，因此对克隆后对象的这些类型成员
    // 进行修改会影响原对象
    @Override
    public Object clone() {
        ShallowClone sc = null;
        try {
            sc = (ShallowClone)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return sc;
    }
}

class DeepClone implements Serializable {
    private static final long serialVersionUID = 1L;
    public int a;
    public int[] b;
    
    public DeepClone() {
        a = 100;
        b = new int[] {100, 2, 3, 4, 5};
    }
    
    // 使用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();
		
		System.out.println("--------->"+oos);
		System.out.println("---------->"+baos);
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream bis = new ObjectInputStream(bais);
        dc = (DeepClone)bis.readObject();
        return dc;
    }

本节非常简单，只是做一下记录，这段代码也是copy的，记录下序列和反序列部分，以备用。