Java对象拷贝详解

一、概述

Java对象拷贝并不是一项容易的任务，我们需要考虑一些细节问题来确保拷贝后的对象能够正常工作。在进行Java对象拷贝时，我们通常需要考虑以下几个方面：

1、拷贝的类型，即浅拷贝和深拷贝

2、拷贝的方式，即手动拷贝和自动拷贝

3、拷贝时需要考虑的问题，如拷贝后的对象是否还能正常工作等

二、浅拷贝和深拷贝

1、浅拷贝：只拷贝对象的基本数据类型，如byte、short、int、long、float、double、char、Boolean等，对于对象类型，只是拷贝对象的引用地址。

public class ShallowCopy implements Cloneable {
    private String name;
    private DeepCopy deepCopy;
    //省略get和set方法

    @Override
    public ShallowCopy clone() throws CloneNotSupportedException {
        return (ShallowCopy) super.clone();
    }
}

public class DeepCopy implements Cloneable {
    private String value;
    //省略get和set方法

    @Override
    public DeepCopy clone() throws CloneNotSupportedException {
        return (DeepCopy) super.clone();
    }
}

public static void main(String[] args) throws CloneNotSupportedException {
    ShallowCopy shallowCopy1 = new ShallowCopy();
    shallowCopy1.setName("copy1");
    DeepCopy deepCopy1 = new DeepCopy();
    deepCopy1.setValue("1");
    shallowCopy1.setDeepCopy(deepCopy1);

    ShallowCopy shallowCopy2 = shallowCopy1.clone();
    System.out.println("shallowCopy1:" + shallowCopy1.hashCode());
    System.out.println("shallowCopy2:" + shallowCopy2.hashCode());
}

输出结果如下：

shallowCopy1:1230609080
shallowCopy2:1230609080

从输出结果可以看出，浅拷贝只是拷贝了引用地址，两个对象使用的是同一份对象数据，当修改一个对象的成员变量时，会影响到另一个对象的成员变量值。

2、深拷贝：是指在拷贝对象时，拷贝对象的基本数据类型和引用类型，不仅拷贝引用地址，而且还会递归拷贝引用的对象。

public class DeepCopy implements Cloneable {
    private String value;
    //省略get和set方法

    @Override
    public DeepCopy clone() throws CloneNotSupportedException {
        DeepCopy deepCopy = (DeepCopy) super.clone();//浅拷贝
        deepCopy.setValue(new String(value));//拷贝String类型

        return deepCopy;
    }
}

public static void main(String[] args) throws CloneNotSupportedException {
    DeepCopy deepCopy1 = new DeepCopy();
    deepCopy1.setValue("copy1");

    DeepCopy deepCopy2 = deepCopy1.clone();
    System.out.println("deepCopy1:" + deepCopy1.hashCode());
    System.out.println("deepCopy2:" + deepCopy2.hashCode());
}

输出结果如下：

deepCopy1:1230609080
deepCopy2:369881802

从输出结果可以看出，深拷贝拷贝了对象的全部数据，两个对象是独立的，修改一个对象的成员变量值不会影响到另一个对象的值。

三、手动拷贝和自动拷贝

1、手动拷贝：是指通过编写代码手动拷贝对象的成员变量，对引用类型需要进行特判，递归拷贝所有的引用对象。

public class ManualClone implements Cloneable {
    private String name;
    private DeepCopy deepCopy;
    //省略get和set方法

    @Override
    public ManualClone clone() throws CloneNotSupportedException {
        ManualClone manualClone = (ManualClone) super.clone();//浅拷贝
        DeepCopy deepCopyClone = deepCopy.clone();//递归拷贝DeepCopy对象
        manualClone.setDeepCopy(deepCopyClone);//手动设置对象引用

        return manualClone;
    }
}

public static void main(String[] args) throws CloneNotSupportedException {
    ManualClone manualClone1 = new ManualClone();
    manualClone1.setName("copy1");
    DeepCopy deepCopy1 = new DeepCopy();
    deepCopy1.setValue("1");
    manualClone1.setDeepCopy(deepCopy1);

    ManualClone manualClone2 = manualClone1.clone();
    System.out.println("manualClone1:" + manualClone1.hashCode());
    System.out.println("manualClone2:" + manualClone2.hashCode());
    System.out.println(manualClone1.getDeepCopy().hashCode() + " " + manualClone2.getDeepCopy().hashCode());
}

输出结果如下：

manualClone1:1230609080
manualClone2:1545102790
1876618298 2083562754

从输出结果可以看出，手动拷贝需要编写大量代码，比较麻烦，而且容易出现错误，对于复杂的对象结构，手动拷贝会非常困难。

2、自动拷贝：是指通过反射机制，自动拷贝对象及其引用的对象，可以减少手动编写代码的工作量。

public class AutoClone implements Cloneable {
    private String name;
    private DeepCopy deepCopy;
    //省略get和set方法

    @Override
    public AutoClone clone() throws CloneNotSupportedException {
        AutoClone autoClone = (AutoClone) super.clone();//浅拷贝
        Field[] fields = this.getClass().getDeclaredFields();//获取所有的成员变量

        try {
            for (Field field : fields) {
                field.setAccessible(true);//取消访问权限检查
                Object fieldObj = field.get(this);//获取成员变量的值
                if (fieldObj != null && fieldObj instanceof Cloneable) {//判断是否需要拷贝
                    field.set(autoClone, ((Cloneable) fieldObj).clone());//递归拷贝
                } else {
                    field.set(autoClone, fieldObj);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return autoClone;
    }
}

public static void main(String[] args) throws CloneNotSupportedException {
    AutoClone autoClone1 = new AutoClone();
    autoClone1.setName("copy1");
    DeepCopy deepCopy1 = new DeepCopy();
    deepCopy1.setValue("1");
    autoClone1.setDeepCopy(deepCopy1);

    AutoClone autoClone2 = autoClone1.clone();
    System.out.println("autoClone1:" + autoClone1.hashCode());
    System.out.println("autoClone2:" + autoClone2.hashCode());
    System.out.println(autoClone1.getDeepCopy().hashCode() + " " + autoClone2.getDeepCopy().hashCode());
}

输出结果如下：

autoClone1:1230609080
autoClone2:922963970
493654135 1690703277

从输出结果可以看出，自动拷贝通过反射机制自动拷贝对象及其引用的对象，可以减少手动编写代码的工作量。

四、拷贝时需要注意的问题

1、拷贝后的对象是否还能正常工作，即是否能够继续使用。

2、如果拷贝的对象存在循环引用，拷贝时会产生死循环，需要避免。

3、如果拷贝的对象存在深度递归引用，建议使用深拷贝，否则拷贝结果可能不符合预期。

4、如果拷贝的对象的成员变量中包含线程、锁等非线程安全对象，需要考虑如何处理。

五、总结

Java对象拷贝并不是一项容易的任务，需要考虑许多问题。通常在进行Java对象拷贝时，我们需要考虑拷贝的类型，即浅拷贝和深拷贝，拷贝的方式，即手动拷贝和自动拷贝，以及拷贝时需要注意的问题。这些问题是需要我们根据实际情况进行综合考虑和处理的，才能确保拷贝后的对象能够正常工作。