java相关总结3--浅克隆和深克隆

其实这种例子网上很多，自己写一遍记下来仅仅只是为了加深印象和以后查找的方便，说明一下：浅克隆只是仅仅修改了引用，是引用传递，并不是值传递。

List<String> listA = new ArrayList<String>();

listA.add("a");

listA.add("b");

List<String> listB = new ArrayList<String>();

listB = listA;

这时栈中有两个变量listA、listB，而堆中只有一个对象A，a和b同时指向这个对象，这时如果修改了listA那么listB理所当然也会改变。

1、基本克隆对象：

package clone;

import java.io.Serializable;

/**
 * 简单克隆基本对象对象
 * @author Administrator
 *
 */
public class CloneObject implements Serializable{
        private String name;
        
        private String sex;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getSex() {
            return sex;
        }

        public void setSex(String sex) {
            this.sex = sex;
        }
        
}

2、含有对象类型的成员变量的克隆对象

package clone;

import java.io.Serializable;

/**
 * 成员变量为对象的对象
 * 用于测试克隆
 * @author Administrator
 *
 */
public class SimpleObject implements Cloneable, Serializable{
        private String childName;
        /**
         * 子对象成员
         */
        private CloneObject object;
        /**
         * 构造函数
         * @param object
         */
        public SimpleObject(CloneObject object){
            this.object = object;
        }
        
        public SimpleObject(){
            
        }
        
        public String getChildName() {
            return childName;
        }

        public void setChildName(String childName) {
            this.childName = childName;
        }

        public CloneObject getObject() {
            return object;
        }

        public void setObject(CloneObject object) {
            this.object = object;
        }
        /**
         * 浅克隆
         * 如果含有对象成员，那么浅克隆后指向的是同一个对象，
         * 克隆后如果修改了被克隆的成员对象的值，那么克隆后的子对象也会改变。
         * @param object
         * @return
         */
        public Object clone(Object object){
            SimpleObject cloneObject = null;
            try{
                cloneObject = (SimpleObject)super.clone();
            }catch(CloneNotSupportedException e){
                e.printStackTrace();
            }
            return cloneObject;
        }
}

3、可能测试主体类

package clone;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 克隆测试类
 * @author Administrator
 *
 */
public class CloneTest {
    public static void main(String[] args){
        
        CloneObject obj = new CloneObject();
        obj.setName("name 1");
        
        SimpleObject object1 = new SimpleObject();
        object1.setObject(obj);
        object1.setChildName("object 1");
        SimpleObject object2 = new SimpleObject();
        object2.setChildName("object 2");
        System.out.println("浅克隆前对象1自有属性为：" + object1.getChildName());
        System.out.println("浅克隆前对象2自有属性为：" + object2.getChildName());
        System.out.println("浅克隆前对象1子对象属性为：" + (null==object1.getObject()?null:object1.getObject().getName()));
        System.out.println("浅克隆前对象2子对象属性为：" + (null==object2.getObject()?null:object2.getObject().getName()));
        //浅克隆
        object2 = (SimpleObject)object1.clone(object1);
        System.out.println();
        
        System.out.println("浅克隆后对象1自有属性为：" + object1.getChildName());
        System.out.println("浅克隆后对象2自有属性为：" + object2.getChildName());
        System.out.println("浅克隆后对象1子对象属性为：" + object1.getObject().getName());
        System.out.println("浅克隆后对象2子对象属性为：" + object2.getObject().getName());
        //浅克隆后修改原有子对象的成员值，即使在被克隆后再去修改，也会修改克隆的对象，因为浅克隆后两个
        //成员对象所指向的地址是一致的
        obj.setName("name update");
        object1.setChildName("object update");
        System.out.println();
        
        System.out.println("浅克隆后修改原对象后对象1自有属性为：" + object1.getChildName());
        System.out.println("浅克隆后修改原对象后对象2自有属性为：" + object2.getChildName());
        System.out.println("浅克隆后修改原对象后对象1子对象属性为：" + object1.getObject().getName());
        System.out.println("浅克隆后修改原对象后对象2子对象属性为：" + object2.getObject().getName());
        
        //深度克隆 克隆后再改变1对象的子对象值，可以发现普通成员可以完成复制，对象成员也没问题。
        object2 = (SimpleObject)cloneDeep(object1);
        System.out.println();
        obj.setName("name update 2");
        object1.setChildName("object update2");
        
        System.out.println("深克隆后修改原对象后对象1自有属性为：" + object1.getChildName());
        System.out.println("深克隆后修改原对象后对象2自有属性为：" + object2.getChildName());
        System.out.println("深克隆后修改原对象后对象1子对象属性为：" + object1.getObject().getName());
        System.out.println("深克隆后修改原对象后对象2子对象属性为：" + object2.getObject().getName());
    }
    /**
     * 通过流来实现深度克隆（浅拷贝为引用拷贝，深拷贝为值拷贝）
     * @param obj
     * @return
     */
    public static final Object cloneDeep(Object obj){
        Object objReturn = null;
        try{
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(obj);//源对象写入内存
            
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            objReturn = ois.readObject();
            
        }catch(IOException e){
            e.printStackTrace();
        }catch(Exception e){
            e.printStackTrace();
        }
        return objReturn;
    }
}

输出结果为：

浅克隆前对象1自有属性为：object 1
浅克隆前对象2自有属性为：object 2
浅克隆前对象1子对象属性为：name 1
浅克隆前对象2子对象属性为：null

浅克隆后对象1自有属性为：object 1
浅克隆后对象2自有属性为：object 1
浅克隆后对象1子对象属性为：name 1
浅克隆后对象2子对象属性为：name 1

浅克隆后修改原对象后对象1自有属性为：object update
浅克隆后修改原对象后对象2自有属性为：object 1
浅克隆后修改原对象后对象1子对象属性为：name update
浅克隆后修改原对象后对象2子对象属性为：name update

深克隆后修改原对象后对象1自有属性为：object update2
深克隆后修改原对象后对象2自有属性为：object update
深克隆后修改原对象后对象1子对象属性为：name update 2
深克隆后修改原对象后对象2子对象属性为：name update