[Java知识库]Java随笔-clone

为什么要使用clone

为什么要使用clone，直接new一个对象不就好了吗，实际使用中，直接new一个对象也不好，解决不了"新数据"会影响原始数据的问题。
这里简单创建了一个测试对象WhyClone。

public class WhyClone {
    private String name;

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

然后创建两个WhyClone 对象，并且使用一个对另一个赋值，赋值之后修改被赋值的内容。

    /**
     * 拷贝产生的原因
     */
    static void whyClone(){
        WhyClone wc1 = new WhyClone();
        wc1.setName("wc1");
        WhyClone wc2 = new WhyClone();
        wc2 = wc1;
        // 输出wc1与wc2的地址
        System.out.println(wc1);
        System.out.println(wc2);
        // 输出wc1与wc2的内容
        System.out.println(wc1.getName());
        System.out.println(wc2.getName());
        // 修改wc2的内容
        wc2.setName("wc2");
        // 输出wc1与wc2的地址
        System.out.println(wc1);
        System.out.println(wc2);
        // 输出wc1与wc2的内容
        System.out.println(wc1.getName());
        System.out.println(wc2.getName());
    }

编译结果：

clone.WhyClone@7a07c5b4
clone.WhyClone@7a07c5b4
wc1
wc1
clone.WhyClone@7a07c5b4
clone.WhyClone@7a07c5b4
wc2
wc2

查看结果发现：wc2被wc1赋值后，wc1和wc2指向同一块地址clone.WhyClone@7a07c5b4，且内容相同，且给wc2赋值字符串”wc2“后，wc1的内容也变成”wc2“。通常开发者需要改变wc2的值且不影响wc1，这就是为什么要使用clone的原因。

clone分为浅拷贝和深拷贝。

浅拷贝

拷贝时，拷贝对象需要实现Cloneable接口，并重写clone() 。

public class ShallowClone implements Cloneable{
    private String name;
    private Inner inner;
    
    public Inner getInner() {
        return inner;
    }
    public void setInner(Inner inner) {
        this.inner = inner;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    public static class Inner{
        public Inner(String tag) {
            this.tag = tag;
        }
        public String  tag;
    }
}

测试代码：

    /**
     * 浅拷贝
     */
    static void shallowClone() throws CloneNotSupportedException {
        ShallowClone sc1 = new ShallowClone();
        sc1.setInner(new ShallowClone.Inner("inner"));
        sc1.setName("sc1");
        ShallowClone sc2 = (ShallowClone) sc1.clone();
        // 输出sc1与sc2的地址
        System.out.println(sc1);
        System.out.println(sc2);
        System.out.println(sc1.getInner());
        System.out.println(sc2.getInner());
        // 输出sc1与sc2的内容
        System.out.println(sc1.getName());
        System.out.println(sc2.getName());
        System.out.println(sc1.getInner().tag);
        System.out.println(sc2.getInner().tag);
        // 是否是浅拷贝
        System.out.println(sc1.getName() == sc2.getName());
        // 修改sc2的内容
        sc2.setName("sc2");
        sc2.getInner().tag = "outer";
        // 输出sc1与sc2的地址
        System.out.println(sc1);
        System.out.println(sc2);
        System.out.println(sc1.getInner());
        System.out.println(sc2.getInner());
        // 输出sc1与sc2的内容
        System.out.println(sc1.getName());
        System.out.println(sc2.getName());
        System.out.println(sc1.getInner().tag);
        System.out.println(sc2.getInner().tag);
    }

编译结果：


比较编译结果发现：直接修改name属性，sc1和sc2并不互相影响，但是两者的Inner指向的是同一个，修改sc2对象Inner的tag属性后，sc1也被修改了，说明ShallowClone.Inner用的同一个，想要一刀两断又没有彻底了断，属于藕断丝连的情况，也就是clone不彻底，称之为浅拷贝。

深拷贝

深拷贝顾名思义就是除了是同一类型的外，所有属性都没有联系，新对象是一块完全独立的内存，两者之间没有任何影响。

public class DeepCloneOuter implements Cloneable{
    public DeepCloneInner deepCloneInner;
    @Override
    public Object clone() throws CloneNotSupportedException {
        DeepCloneOuter deepCloneOuter = (DeepCloneOuter) super.clone();
        deepCloneOuter.deepCloneInner = (DeepCloneInner) deepCloneInner.clone();
        return deepCloneOuter;
    }
}

public class DeepCloneInner implements Cloneable, Serializable {
    private String name;

    public String getName() {
        return name;
    }

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

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

测试代码：

    /**
     * 深拷贝
     */
    static void deepClone() {
        System.out.println("*****************************");
        DeepCloneOuter deepCloneOuter = new DeepCloneOuter();
        deepCloneOuter.deepCloneInner = new DeepCloneInner();
        deepCloneOuter.deepCloneInner.setName("source");

        try {
            DeepCloneOuter deepCloneOuter2 = (DeepCloneOuter) deepCloneOuter.clone();
            System.out.println(deepCloneOuter);
            System.out.println(deepCloneOuter2);
            System.out.println(deepCloneOuter.deepCloneInner.getName());
            System.out.println(deepCloneOuter2.deepCloneInner.getName());
            System.out.println(deepCloneOuter.deepCloneInner.getName() == deepCloneOuter2.deepCloneInner.getName());
            System.out.println(deepCloneOuter.deepCloneInner == deepCloneOuter2.deepCloneInner);
            // 修改内容
            deepCloneOuter2.deepCloneInner.setName("clone");
            System.out.println(deepCloneOuter);
            System.out.println(deepCloneOuter2);
            System.out.println(deepCloneOuter.deepCloneInner.getName());
            System.out.println(deepCloneOuter2.deepCloneInner.getName());
            System.out.println(deepCloneOuter.deepCloneInner.getName() == deepCloneOuter2.deepCloneInner.getName());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }

编译结果：

clone.DeepCloneOuter@68de145
clone.DeepCloneOuter@27fa135a
source
source
true
false
clone.DeepCloneOuter@68de145
clone.DeepCloneOuter@27fa135a
source
clone
false
false

编译结果说明深拷贝拷中的对象除了长得像，初此之外没有任何联系。当拷贝对象比较复杂的时候，该拷贝方法需要单独拷贝很多东西，所以不常用，利用序列化拷贝对象较为常用。

序列化深拷贝

序列化深拷贝是通过序列化对象，之后反序列化，利用字节流写入被拷贝对象并读取后得到新对象，相当于用户参照被拷贝对象手动开辟了一块新内存供新对象使用。
需要拷贝的对象只要实现Serializable即可。

public class SerializationClone implements Serializable {
    private String name;
    private Inner inner;
    public Inner getInner() {
        return inner;
    }
    public void setInner(Inner inner) {
        this.inner = inner;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static class Inner implements Serializable{
        private String tag;

        public String getTag() {
            return tag;
        }
        public void setTag(String tag) {
            this.tag = tag;
        }
    }
}```

拷贝工具：

```java
public class CloneUtil {

    public static <T extends Serializable> T clone(T objection){
        T cloneObjection = null;
        try {
            // 创建写入字节流
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ObjectOutputStream obs = new ObjectOutputStream(out);
            // 写入被拷贝对象
            obs.writeObject(objection);
            // 关闭字节流输入流
            obs.close();

            // 创建字节输入流，分配内存，写入原始对象，生成新对象
            ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(ios);
            // 返回生成的新对象
            cloneObjection = (T) ois.readObject();
            // 关闭对象输入流
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 返回新对象
        return cloneObjection;
    }
}

测试代码：

    /**
     * 序列花拷贝
     */
    static void serializationClone(){
        SerializationClone serializationClone = new SerializationClone();
        serializationClone.setName("serializationClone");
        SerializationClone.Inner inner = new SerializationClone.Inner();
        inner.setTag("serializationCloneTag");
        serializationClone.setInner(inner);
        // 输出原数据
        System.out.println("**************原数据**********");
        System.out.println(serializationClone);
        System.out.println(serializationClone.getInner());
        System.out.println(serializationClone.getName());
        System.out.println(serializationClone.getInner().getTag());

        // 拷贝后
        SerializationClone serializationClone1 = CloneUtil.clone(serializationClone);
        System.out.println("**************拷贝后**********");
        System.out.println(serializationClone1);
        System.out.println(serializationClone1.getInner());
        System.out.println(serializationClone1.getName());
        System.out.println(serializationClone1.getInner().getTag());

        // 修改
        serializationClone1.setName("serializationClone1");
        serializationClone1.getInner().setTag("serializationClone1Tag1");
        // 原数据
        System.out.println("**************修改后原数据**********");
        System.out.println(serializationClone);
        System.out.println(serializationClone.getInner());
        System.out.println(serializationClone.getName());
        System.out.println(serializationClone.getInner().getTag());
        // 拷贝后修改的数据
        System.out.println("**************修改后拷贝数据**********");
        System.out.println(serializationClone1);
        System.out.println(serializationClone1.getInner());
        System.out.println(serializationClone1.getName());
        System.out.println(serializationClone1.getInner().getTag());
    }

编译结果：

**************原数据**********
clone.SerializationClone@26a1ab54
clone.SerializationClone$Inner@3d646c37
serializationClone
serializationCloneTag
**************拷贝后**********
clone.SerializationClone@156643d4
clone.SerializationClone$Inner@123a439b
serializationClone
serializationCloneTag
**************修改后原数据**********
clone.SerializationClone@26a1ab54
clone.SerializationClone$Inner@3d646c37
serializationClone
serializationCloneTag
**************修改后拷贝数据**********
clone.SerializationClone@156643d4
clone.SerializationClone$Inner@123a439b
serializationClone1
serializationClone1Tag1

比较拷贝前后的对象发现两者地址都不一样，包括内部对象的地址，修改任何属性也不会相互影响。

深拷贝建议使用序列化深拷贝