深入理解Java中的克隆

前言

java克隆(clone)是java语言的特性之一，但在实际中应用比较少见。但有时候用克隆会更方便更有效率。

对于克隆(clone)，java有一些限制：

      1、被克隆的类必须自己实现cloneable 接口，以指示 object.clone() 方法可以合法地对该类实例进行按字段复制。cloneable 接口实际上是个标识接口，没有任何接口方法。

      2、实现cloneable接口的类应该使用公共方法重写 object.clone（它是受保护的）。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的，也无法保证它将获得成功。

      3、在java.lang.object类中克隆方法是这么定义的：

        protected object clone()
        throws clonenotsupportedexception

创建并返回此对象的一个副本。表明是一个受保护的方法，同一个包中可见。

按照惯例，返回的对象应该通过调用 super.clone 获得。

java中的赋值

在java中，赋值是很常用的，一个简单的赋值如下

//原始类型
int a = 1;
int b = a;

//引用类型
string[] weekdays = new string[5];
string[] gongzuori = weekdays;//仅拷贝引用

在上述代码中。

      1、如果是原始数据类型，赋值传递的为真实的值

      2、如果是引用数据类型，赋值传递的为对象的引用，而不是对象。

了解了数据类型和引用类型的这个区别，便于我们了解clone。

clone

在java中，clone是将已有对象在内存中复制出另一个与之相同的对象的过程。java中的克隆为逐域复制。

在java中想要支持clone方法，需要首先实现cloneable接口

cloneable其实是有点奇怪的，它不同与我们常用到的接口，它内部不包含任何方法，它仅仅是一个标记接口。

其源码如下

public interface cloneable {
}

关于cloneable，需要注意的

      1、如果想要支持clone，就需要实现cloneable 接口

      2、如果没有实现cloneable接口的调用clone方法，会抛出clonenotsupportedexception异常。

然后是重写clone方法，并修改成public访问级别

static class cloneableimp implements cloneable {
 public int count;
 public child child;
   
   
 @override
 public object clone() throws clonenotsupportedexception {
   return super.clone();
 }
}

调用clone方法复制对象

cloneableimp imp1 = new cloneableimp();
imp1.child = new child("andy");
try {
 object obj = imp1.clone();
 cloneableimp imp2 = (cloneableimp)obj;
 system.out.println("main imp2.child.name=" + imp2.child.name);
} catch (clonenotsupportedexception e) {
 e.printstacktrace();
}

浅拷贝

上面的代码实现的clone实际上是属于浅拷贝（shallow copy）。

关于浅拷贝，你该了解的

     1、使用默认的clone方法

     2、对于原始数据域进行值拷贝

     3、对于引用类型仅拷贝引用

     4、执行快，效率高

     5、不能做到数据的100%分离。

     6、如果一个对象只包含原始数据域或者不可变对象域，推荐使用浅拷贝。

关于无法做到数据分离，我们可以使用这段代码验证

cloneableimp imp1 = new cloneableimp();
imp1.child = new child("andy");
try {
 object obj = imp1.clone();
 cloneableimp imp2 = (cloneableimp)obj;
 imp2.child.name = "bob";
     
 system.out.println("main imp1.child.name=" + imp1.child.name);
} catch (clonenotsupportedexception e) {
 e.printstacktrace();
}

上述代码我们使用了imp1的clone方法克隆出imp2,然后修改 imp2.child.name 为 bob,然后打印imp1.child.name 得到的结果是

main imp1.child.name=bob

原因是浅拷贝并没有做到数据的100%分离，imp1和imp2共享同一个child对象，所以一个修改会影响到另一个。

深拷贝

深拷贝可以解决数据100%分离的问题。只需要对上面代码进行一些修改即可。

1、child实现cloneable接口。

public class child implements cloneable{

 public string name;

 public child(string name) {
   this.name = name;
 }

 @override
 public string tostring() {
   return "child [name=" + name + "]";
 }

 @override
 protected object clone() throws clonenotsupportedexception {
   return super.clone();
 }
}

2.重写clone方法，调用数据域的clone方法。

static class cloneableimp implements cloneable {
 public int count;
 public child child;
   
   
 @override
 public object clone() throws clonenotsupportedexception {
   cloneableimp obj = (cloneableimp)super.clone();
   obj.child = (child) child.clone();
   return obj;
 }
}

当我们再次修改imp2.child.name就不会影响到imp1.child.name的值了，因为imp1和imp2各自拥有自己的child对象，因为做到了数据的100%隔离。

关于深拷贝的一些特点

      1、需要重写clone方法，不仅仅只调用父类的方法，还需调用属性的clone方法

      2、做到了原对象与克隆对象之间100%数据分离

      3、如果是对象存在引用类型的属性，建议使用深拷贝

      4、深拷贝比浅拷贝要更加耗时，效率更低

为什么使用克隆

很重要并且常见的常见就是：某个api需要提供一个list集合，但是又不希望调用者的修改影响到自身的变化，因此需要克隆一份对象，以此达到数据隔离的目的。

应尽量避免clone

      1.通常情况下，实现接口是为了表明类可以为它的客户做些什么，而cloneable仅仅是一个标记接口，而且还改变了超类中的手保护的方法的行为，是接口的一种极端非典型的用法，不值得效仿。

      2.clone方法约定及其脆弱 clone方法的javadoc描述有点暧昧模糊，如下为 java se8的约定

          clone方法创建并返回该对象的一个拷贝。而拷贝的精确含义取决于该对象的类。一般的含义是，对于任何对象x，表达式

          x.clone() != x 为 true x.clone().getclass() == x.getclass() 也返回true，但非必须 x.clone().equals(x) 也返回true，但也不是必须的

上面的第二个和第三个表达式很容易就返回false。因而唯一能保证永久为true的就是表达式一，即两个对象为独立的对象。

       3.可变对象final域 在克隆方法中，如果我们需要对可变对象的final域也进行拷贝，由于final的限制，所以实际上是无法编译通过的。因此为了实现克隆，我们需要考虑舍去该可变对象域的final关键字。

       4.线程安全 如果你决定用线程安全的类实现cloneable接口，需要保证它的clone方法做好同步工作。默认的object.clone方法是没有做同步的。

总的来说，java中的clone方法实际上并不是完善的，建议尽量避免使用。如下是一些替代方案。

copy constructors

使用复制构造器也可以实现对象的拷贝。

      1、复制构造器也是构造器的一种

      2、只接受一个参数，参数类型为当前的类

      3、目的是生成一个与参数相同的新对象

      4、复制构造器相比clone方法的优势是简单，易于实现。

一段使用了复制构造器的代码示例

public class car {
 wheel wheel;
 string manufacturer;
 
 public car(wheel wheel, string manufacturer) {
   this.wheel = wheel;
   this.manufacturer = manufacturer;
 }
 
 //copy constructor
 public car(car car) {
   this(car.wheel, car.manufacturer);
 }
 
 public static class wheel {
   string brand;
 }
}

注意，上面的代码实现为浅拷贝，如果想要实现深拷贝，参考如下代码

//copy constructor
public car(car car) {
 wheel wheel = new wheel();
 wheel.brand = car.wheel.brand;
   
 this.wheel = wheel;
 this.manufacturer = car.manufacturer;
}

为了更加便捷，我们还可以为上述类增加一个静态的方法

public static car newinstance(car car) {
 return new car(car);
}

使用serializable实现深拷贝

其实，使用序列化也可以实现对象的深拷贝。简略代码如下

public class deepcopyexample implements serializable{
 private static final long serialversionuid = 6098694917984051357l;
 public child child;
 
 public deepcopyexample copy() {
   deepcopyexample copy = null;
   try {
     bytearrayoutputstream baos = new bytearrayoutputstream();
     objectoutputstream oos = new objectoutputstream(baos);
     oos.writeobject(this);
 
     bytearrayinputstream bais = new bytearrayinputstream(baos.tobytearray());
     objectinputstream ois = new objectinputstream(bais);
     copy = (deepcopyexample) ois.readobject();
   } catch (ioexception e) {
     e.printstacktrace();
   } catch (classnotfoundexception e) {
     e.printstacktrace();
   }
   return copy;
 }
}

其中，child必须实现serializable接口

public class child implements serializable{
 private static final long serialversionuid = 6832122780722711261l;
 public string name = "";

 public child(string name) {
   this.name = name;
 }

 @override
 public string tostring() {
   return "child [name=" + name + "]";
 }
}

使用示例兼测试代码

deepcopyexample example = new deepcopyexample();
example.child = new child("example");
   
deepcopyexample copy = example.copy();
if (copy != null) {
 copy.child.name = "copied";
 system.out.println("example.child=" + example.child + ";copy.child=" + copy.child);
}
//输出结果：example.child=child [name=example];copy.child=child [name=copied]

由输出结果来看，copy对象的child值修改不影响example对象的child值，即使用序列化可以实现对象的深拷贝。

总结

以上就是java中克隆的全部内容，希望本文对大家学习java能有所帮助。