JAVA深度克隆

最新推荐文章于 2024-03-29 17:02:05 发布

ManerFan

最新推荐文章于 2024-03-29 17:02:05 发布

阅读量1.8k

点赞数

分类专栏： Java javascript 文章标签： java

本文链接：https://blog.csdn.net/manerfan/article/details/49798395

版权

Java 同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

javascript

4 篇文章 0 订阅

订阅专栏

JAVA深度克隆

对于JAVA的克隆，其实可以采取两种办法
1. 写一个克隆方法（或重写Object的clone()），方法内自行new一个对象，赋值并返回
2. 实现Cloneable接口，并使用super.clone()方法（Object.clone）

这里重点介绍一下方法2

JAVA深度克隆
JAVASCRIPT深度克隆

Object.clone()

Object中已经提供了clone的支持，从源码中可以看到，该方法被native修饰
protected native Object clone() throws CloneNotSupportedException;
对于JAVA为什么要用native而不直接使用JAVA实现并不清楚，但可以肯定的是，使用native方法要比使用new效率更高。

以下附上Object.clone()方法的文档1

Creates and returns a copy of this object. The precise meaning
of “copy” may depend on the class of the object. The general
intent is that, for any object x, the expression:
x.clone() != x
will be true, and that the expression:
x.clone().getClass() == x.getClass()
will be true, but these are not absolute requirements.
While it is typically the case that:
x.clone().equals(x)
will be true, this is not an absolute requirement.

By convention, the returned object should be obtained by calling
super.clone. If a class and all of its superclasses (except
Object) obey this convention, it will be the case that
x.clone().getClass() == x.getClass().

By convention, the object returned by this method should be independent
of this object (which is being cloned). To achieve this independence,
it may be necessary to modify one or more fields of the object returned
by super.clone before returning it. Typically, this means
copying any mutable objects that comprise the internal “deep structure”
of the object being cloned and replacing the references to these
objects with references to the copies. If a class contains only
primitive fields or references to immutable objects, then it is usually
the case that no fields in the object returned by super.clone
need to be modified.

The method clone for class Object performs a
specific cloning operation. First, if the class of this object does
not implement the interface Cloneable, then a
CloneNotSupportedException is thrown. Note that all arrays
are considered to implement the interface Cloneable and that
the return type of the clone method of an array type T[]
is T[] where T is any reference or primitive type.
Otherwise, this method creates a new instance of the class of this
object and initializes all its fields with exactly the contents of
the corresponding fields of this object, as if by assignment; the
contents of the fields are not themselves cloned. Thus, this method
performs a “shallow copy” of this object, not a “deep copy” operation.

The class Object does not itself implement the interface
Cloneable, so calling the clone method on an object
whose class is Object will result in throwing an
exception at run time.

从JAVA的文档中可以看出
1. clone方法返回对象的副本，而不是引用。即，对任何对象x，均满足x.clone() != x
2. 对任何对象x，均满足x.clone().getClass() == x.getClass()，即，克隆对象与原对象同属一种类型
3. 对任何对象x，均满足x.clone().equals(s) == true
4. 若要使用clone方法，需要对象x实现Cloneable接口，复写clone方法并生命为public（若不实现Cloneable接口，使用clone方法会抛出CloneNotSupportedException异常）

简单来说，JAVA的clone方法，就是在内存里开辟了一块儿与原对象一模一样的空间，这样就保证了对象副本与原对象既不属于同一个对象（内存地址不一样），内容又完全相同。但对于对象中的非基本类型参数，副本与原对象持有的都是同一引用，这样一来，在原对象(副本对象)中对非基本类型参数的修改，都会体现到副本对象（原对象）中，这也就是所说的浅克隆。

浅克隆

首先，创建两个对象，如下

public class OrigClass implements Cloneable {

    /**
     * 基础类型 - 字符串
     */
    private String str;

    /**
     * 基础类型 - 数字
     */
    private int i;

    /**
     * 对象
     */
    private ParamClass param;

    /**
     * 对象序列
     */
    private List<ParamClass> params;

    public OrigClass(String str, int i, ParamClass param, List<ParamClass> params) {
        this.str = str;
        this.i = i;
        this.param = param;
        this.params = params;
    }

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

    // 略去 getter setter
}

public class ParamClass {

    /**
     * 基础类型 - 字符串
     */
    private String str;

    /**
     * 基础类型 - 数字
     */
    private int i;

    public ParamClass(String str, int i) {
        this.str = str;
        this.i = i;
    }

    // 略去 getter setter
}

执行如下

System.out.println("= = = = = = = = = = = = =");

System.out.println("[orig != copy] " + (orig != copy));
System.out.println("[orig.getClass() == copy.getClass()] " + (orig.getClass() == copy.getClass()));
System.out.println("[orig] " + Integer.toHexString(orig.hashCode()));
System.out.println("[copy] " + Integer.toHexString(copy.hashCode()));
System.out.println("[orig.param] " + Integer.toHexString(orig.getParam().hashCode()));
System.out.println("[copy.param] " + Integer.toHexString(copy.getParam().hashCode()));

System.out.println("= = = = = = = = = = = = =");

System.out.println("[orig.string] " + orig.getStr());
System.out.println("[copy.string] " + copy.getStr());

orig.setStr("orig-modify");

System.out.println("[orig.string] " + orig.getStr());
System.out.println("[copy.string] " + copy.getStr());      

System.out.println("= = = = = = = = = = = = =");

System.out.println("[orig.param.string] " + orig.getParam().getStr());
System.out.println("[copy.param.string] " + copy.getParam().getStr());

orig.getParam().setStr("param-modify");

System.out.println("[orig.param.string] " + orig.getParam().getStr());
System.out.println("[copy.param.string] " + copy.getParam().getStr());

System.out.println("= = = = = = = = = = = = =");

执行结果如下
= = = = = = = = = = = = = [orig != copy] true [orig.getClass() == copy.getClass()] true [orig] 2278e185 [copy] 2e1df471 [orig.param] 309b3e5e [copy.param] 309b3e5e = = = = = = = = = = = = = [orig.string] orig [copy.string] orig [orig.string] orig-modify [copy.string] orig = = = = = = = = = = = = = [orig.param.string] param [copy.param.string] param [orig.param.string] param-modify [copy.param.string] param-modify = = = = = = = = = = = = =

从执行结果可以看出
1. orig与copy内存地址不一样，但各自param参数的内存地址却是一样的
2. 修改orig中的基本类型string参数，并不会影响到copy
3. 修改orig中的引用类型param参数，会直接反应到copy中

深克隆

通过上边的示例可以看出，若想实现深度克隆，需要在clone方法里对非基本类型对象继续做clone操作

这里，我们将OrigClass跟ParamClass做一些修改

public class OrigClass implements Cloneable {

    /**
     * 基础类型 - 字符串
     */
    private String str;

    /**
     * 基础类型 - 数字
     */
    private int i;

    /**
     * 对象
     */
    private ParamClass param;

    /**
     * 对象序列
     */
    private List<ParamClass> params;

    public OrigClass(String str, int i, ParamClass param, List<ParamClass> params) {
        this.str = str;
        this.i = i;
        this.param = param;
        this.params = params;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        OrigClass clone = (OrigClass) super.clone();

        /* 对于非基本类型，需要递归克隆 */

        if (null != param) {
            clone.setParam((ParamClass) param.clone());
        }

        if (null != params && !params.isEmpty()) {
            List<ParamClass> ps = new LinkedList<>();
            for (ParamClass p : params) {
                ps.add((ParamClass) p.clone());
            }

            clone.setParams(ps);
        }

        return clone;
    }

    // 略去 setter setter
}

public class ParamClass implements Cloneable {

    /**
     * 基础类型 - 字符串
     */
    private String str;

    /**
     * 基础类型 - 数字
     */
    private int i;

    public ParamClass(String str, int i) {
        this.str = str;
        this.i = i;
    }

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

    // 略去 setter getter
}

再次执行以上测试程序，结果如下
= = = = = = = = = = = = = [orig != copy] true [orig.getClass() == copy.getClass()] true [orig] 34feb215 [copy] 3d5d9be1 [orig.param] 4ca4f040 [copy.param] 6099210f = = = = = = = = = = = = = [orig.string] orig [copy.string] orig [orig.string] orig-modify [copy.string] orig = = = = = = = = = = = = = [orig.param.string] param [copy.param.string] param [orig.param.string] param-modify [copy.param.string] param = = = = = = = = = = = = =

从运行结果可以看出，orig中参数param的内存地址与copy中param的内存地址已不同，并且修改orig中的引用类型param参数，再不会影响到copy中。
这也就实现了深度克隆的目的。

同样的，如果ParamClass对象中存在非基本类型参数，那在ParamClass的clone方法中也需要对非基本类型参数做克隆操作（如同OrigClass.clone），以此类推。

简单来说，如果对象实现Cloneable接口，那在clone方法中就需要继续对非基本类型对象做clone.

JAVASCRIPT深度克隆

JAVASCRIPT中的深度克隆与上述思想相同，即需要对非基本类型参数做递归克隆，代码如下

/**
 * 对象深度克隆
 * @param obj
 * @returns {object}
 */
function clone(obj) {
    var o;
    if (typeof obj == "object") { // 非基本类型
        if (obj === null) {
            o = null;
        } else {
            if (obj instanceof Array) { // 序列，需要递归克隆
                o = [];
                for (var i = 0, len = obj.length; i < len; i++) {
                    o.push(clone(obj[i]));
                }
            } else {
                o = {};
                for (var j in obj) { // 对象中的每一个参数，都需要递归克隆
                    o[j] = clone(obj[j]);
                }
            }
        }
    } else {  // 基本类型
        o = obj;
    }
    return o;
}