java进阶6 -「深浅拷贝」

浅拷贝：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点），不过，如果原对象内部的属性是引用类型的话，浅拷贝会直接复制内部对象的引用地址，也就是说拷贝对象和原对象共用同一个内部对象。

深拷贝：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。

 

一 demo演示

1 Professor类

class Professor implements Serializable, Cloneable {
    private static final long serialVersionUID = 1286716519490813020L;
    public String name;
    public int age;

    // 构造函数是为了CloneUtils json序列化使用
    public Professor() {
    }

    public Professor(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

 

2. Student类

class Student implements Serializable, Cloneable {
    private static final long serialVersionUID = -547004870369127943L;
    public String name;
    public int age;
    public Professor p;

    // 构造函数是为了CloneUtils工具类clazz.instance()方法调用 & json序列化使用
    public Student() {
    }

    public Student(String name, int age, Professor p) {
        this.name = name;
        this.age = age;
        this.p = p;
    }

    public Object shallowClone() throws CloneNotSupportedException {
        Student s = (Student) super.clone();
        //s.p = (Professor) p.clone();  //这句加上就是深拷贝了
        return s;
    }
}

 

3 CloneUtils类

@SuppressWarnings("unchecked")
public class CloneUtils {

    /**
     * 浅拷贝
     */
    public static <T> T shallowClone(T t) {
        try {
            if (t == null) {
                return null;
            }

            Class<? extends T> clazz = (Class<? extends T>) t.getClass();
            T instance = clazz.newInstance();

            Field[] fields = clazz.getDeclaredFields();
            if (fields != null) {
                for (Field field : fields) {
                    int modifiers = field.getModifiers();
                    if (Modifier.isFinal(modifiers) || Modifier.isStatic(modifiers)) { //final的无法拷贝, static的无需拷贝
                        continue;
                    }
                    field.setAccessible(true);
                    field.set(instance, field.get(t));
                }
            }
            return instance;
        } catch (Exception e) {
            System.out.printf("error" + e);
            // ignore
        }
        return null;
    }

    /**
     * 深拷贝
     */
    public static <T> T deepClone(T t, Class<T> clazz) throws IOException {
        try {
            if (t == null || clazz == null) {
                return null;
            }
            return JsonUtils.toBean(JsonUtils.toJson(t), clazz);
        } catch (Exception e) {
            System.out.printf("error" + e);
            // ignore
        }
        return null;
    }
}

 

4 Main

class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException, CloneNotSupportedException {
        Professor p = new Professor("教授1", 50);
        Student s1 = new Student("学生1", 18, p);
//        Student s2 = (Student) s1.shallowClone();
//        Student s2 = CloneUtils.shallowClone(s1);
        Student s2 = CloneUtils.deepClone(s1, Student.class);
        s2.p.name = "教授2";
        s2.p.age = 30;
        s2.name = "学生2";
        s2.age = 25;
        System.out.println(s1.name + " " + s1.age + " " + s1.p.name + " " + s1.p.age);
    }
}

 第5行输出结果:   学生1 18 教授2 30

 第6行输出结果:   学生1 18 教授2 30

 第7行输出结果:    学生1 18 教授1 50

 

二 分析

上面的shallow clone只是实体的所有数据&引用进行了简单拷贝，这样会出现修改拷贝类s2中的引用指针p时，会影响原始的实体s1.p，造成不可预知的错误

可以看到把Student类中的引用p也进行clone就是深拷贝了（Student#line19注释打开）

或者直接用序列化的方式进行深拷贝，深拷贝的原始实体和拷贝实体毫无关系，不会互相影响

 

 

(借用网上的一个图, Address为代指上文代码的Processor， Person代指上文的Student)