浅谈java浅拷贝与深拷贝

java实现拷贝最直观的做法用object类中的clone()方法，而想要使用该方法进行对象的克隆只要实现cloneable接口即可；

1.浅拷贝

public class FatherClass implements Cloneable{
    private String name;
    private String age;
    private ChildA childA;
    private ChildB childB;
    //省略getter(),setter()方法
    //重写clone()方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class ChildA {
    private String name;
    private String age;
}

测试一下克隆方法：

    public static void main(String [] args) throws Exception{
        //设置对象内容
        FatherClass father = new FatherClass();
        father.setAge("18");
        father.setName("wp");
        //设置对其他对象的引用
        ChildA a = new ChildA();
        father.setChildA(a);
        father.getChildA().setName("gzx");
        father.getChildA().setAge("20");
        //拷贝对象
        FatherClass father2 = (FatherClass) father.clone();
        //判断复制后的对象是否跟原对象相同
        System.out.println("father == father2 :"+(father==father2));
        //比较两个对象的hashCode
        System.out.println("father hash:"+father.hashCode());
        System.out.println("father2 hash:"+father2.hashCode());
        //比较两个对象是否引用了同一个对象
        System.out.println("father.childA == father2.childA:"+(father.getChildA()==father2.getChildA()));
        System.out.println("father.childA.hashCode == father2.childA.hashCode:"+(father.getChildA().hashCode()==father2.getChildA().hashCode()));

        //改变原有对象的内容
        father.setName("wp2");
        father.getChildA().setName("lx");

        //查看克隆对象的内容
        //基本类型
        System.out.println("father.name:"+father.getName());
        System.out.println("father2.name:"+father2.getName());
        //引用类型
        System.out.println("father.childA.name:"+father.getChildA().getName());
        System.out.println("father2.childA.name:"+father2.getChildA().getName());
    }

控制台输出结果：

father == father2 :false//false表示创建了不同的对象
//两个对象的hashCode不同
father hash:356573597
father2 hash:1735600054
//clone()之后两个对象有相同的引用
father.childA == father2.childA:true
father.childA.hashCode == father2.childA.hashCode:true
//改变原对象基本数据类型之后，不会影响复制后的对象
//此处说法不严谨！String是不可变引用，暂且看作基本类型
father.name:wp2
father2.name:wp
//改变原对象引用对象的内容，拷贝后的对象也随之改变
father.childA.name:lx
father2.childA.name:lx

上例说明，基本数据类型（包括不可变引用String类型）没有浅拷贝这种说法，浅拷贝是针对引用类型而言的。

2.1 用clone()方法实现深拷贝

ChildB类也需要实现cloneable接口

public class ChildB implements Cloneable{
    private String name;
    private String age;
    //省略getter(),setter()方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

FatherClass的clone()方法重写是重点：

    @Override
    protected Object clone() {
        FatherClass father = null;
        try{
            father =  (FatherClass) super.clone();
            father.childB = (ChildB) this.childB.clone();
        }catch (Exception e){

        }
        return father;
    }

测试一下：

    public static void main(String[]args) throws Exception{
        //设置对象内容
        FatherClass father = new FatherClass();
        father.setAge("18");
        father.setName("wp");
        //设置对其他对象的引用
        ChildB a = new ChildB();
        father.setChildB(a);
        father.getChildB().setName("gzx");
        father.getChildB().setAge("20");
        //拷贝对象
        FatherClass father2 = (FatherClass) father.clone();
        //判断复制后的对象是否跟原对象相同
        System.out.println("father == father2 :"+(father==father2));
        //比较两个对象的hashCode
        System.out.println("father hash:"+father.hashCode());
        System.out.println("father2 hash:"+father2.hashCode());
        //比较两个对象是否引用了同一个对象
        System.out.println("father.childB == father2.childB:"+(father.getChildB()==father2.getChildB()));
        System.out.println("father.childB.hashCode == father2.childB.hashCode:"+(father.getChildB().hashCode()==father2.getChildB().hashCode()));

        //改变原有对象的内容
        father.setName("wp2");
        father.getChildB().setName("lx");

        //查看克隆对象的内容
        //基本类型
        System.out.println("father.name:"+father.getName());
        System.out.println("father2.name:"+father2.getName());
        //引用类型
        System.out.println("father.childB.name:"+father.getChildB().getName());
        System.out.println("father2.childB.name:"+father2.getChildB().getName());
    }

查看控制台输出结果：

//复制了一个新的对象
father == father2 :false
father hash:356573597
father2 hash:1735600054
//原对象的ChildB也复制了一个新的
father.childB == father2.childB:false
father.childB.hashCode == father2.childB.hashCode:false
//改变原有对象不影响新的对象内容
father.name:wp2
father2.name:wp
father.childB.name:lx
father2.childB.name:gzx

2.2 利用serializable实现克隆

    public static Object deepCopy(Object originObj) {
        Object obj = null;
        try {
            //把对象写到流里
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(originObj);

            //从流里读取对象
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            obj = ois.readObject();
        }catch (Exception e){
            //异常处理
            e.printStackTrace();
        }
        return obj;
    }

FatherClass father2 = (FatherClass) deepCopy(father);

注意：FatherClass及其引用的类都必须实现serializable接口，否则无法序列化。

对于两种深拷贝的选择：

• 重写clone()方法效率高，但是一旦一个对象中存在多个对其他对象的引用，或者存在嵌套引用，那每层引用都需要重写clone()方法，代码复杂度加大；
• 序列化能够复制整个对象，包括所有的引用，很方便，但同对象的效率比clone()方法低太多；

个人建议使用clone()方法来实现深拷贝；当业务存在多层的引用，那模型的设计就值得商榷了。