深入探讨JAVA clone

来源：互联网发布：手机淘宝客服在哪里找编辑：程序博客网时间：2024/05/21 17:06

为了理解java的clone，有必要先温习以下的知识。
java的类型，java的类型分为两大类，一类为primitive，如int，另一类为引用类型,如String,Object等等。
java引用类型的存储，java的引用类型都是存储在堆上的。

public class B {int a;String b;public B(int a, String b) {super();this.a = a;this.b = b;}}

对这样一个引用类型的实例，我们可以推测，在堆上它的内存存储形式（除去指向class的引用，锁的管理等等内务事务所占内存），应该有一个int值表示a,以及一个引用，该引用指向b在堆上的存储空间。

为什么要clone

恩，因为需要。废话。
有名的GoF设计模式里有一个模式为原型模式，用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.
简单的说就是clone一个对象实例。使得clone出来的copy和原有的对象一模一样。
问题来了，什么叫一模一样。
一般来说，有
x.clone() != x
x.clone().getClass() == x.getClass()
x.clone().equals(x)
但是这些都不是强制的。
我们需要什么样的clone就搞出什么样的clone好了。
一般而言，我们要的clone应该是这样的。copy和原型的内容一样，但是又是彼此隔离的。即在clone之后，改变其中一个不影响另外一个。

Object的clone

Object的clone的行为是最简单的。以堆上的内存存储解释的话（不计内务内存），对一个对象a的clone就是在堆上分配一个和a在堆上所占存储空间一样大的一块地方，然后把a的堆上内存的内容复制到这个新分配的内存空间上。
看例子。

class User {String name;int age;}class Account implements Cloneable {User user;long balance;@Overridepublic Object clone() throws CloneNotSupportedException {return super.clone();}}

User user = new User();user.name = "user";user.age = 20;// account.Account account = new Account();account.user = user;account.balance = 10000;// copy.Account copy = (Account) account.clone();// balance因为是primitive，所以copy和原型是相等且独立的。Assert.assertEquals(copy.balance, account.balance);copy.balance = 20000;// 改变copy不影响原型。Assert.assertTrue(copy.balance != account.balance);// user因为是引用类型，所以copy和原型的引用是同一的。Assert.assertTrue(copy.user == account.user);copy.user.name = "newName";// 改变的是同一个东西。Assert.assertEquals("newName", account.user.name);

恩，默认实现是帮了我们一些忙，但是不是全部。
primitive的确做到了相等且隔离。
引用类型仅仅是复制了一下引用，copy和原型引用的东西是一样的。
这个就是所谓的浅copy了。
要实现深copy，即复制原型中对象的内存copy，而不仅仅是一个引用。只有自己动手了。
等等，是不是所有的引用类型都需要深copy呢？
不是！
我们之所以要深copy，是因为默认的实现提供的浅copy不是隔离的，换言之，改变copy的东西，会影响到原型的内部。比如例子中，改变copy的user的name，影响了原型。
如果我们要copy的类是不可变的呢，如String，没有方法可以改变它的内部状态呢。

// user.User user = new User();user.name = "user";user.age = 20;// copyUser copy = (User) user.clone();// age因为是primitive，所以copy和原型是相等且独立的。Assert.assertEquals(copy.age, user.age);copy.age = 30;// 改变copy不影响原型。Assert.assertTrue(copy.age != user.age);// name因为是引用类型，所以copy和原型的引用是同一的。Assert.assertTrue(copy.name == user.name);// String为不可变类。没有办法可以通过对copy.name的字符串的操作改变这个字符串。// 改变引用新的对象不会影响原型。copy.name = "newname";Assert.assertEquals("newname", copy.name);Assert.assertEquals("user", user.name);

可见，在考虑clone时，primitive和不可变对象类型是可以同等对待的。

如何clone
clone三部曲。
1 声明实现Cloneable接口。
2 调用super.clone拿到一个对象，如果父类的clone实现没有问题的话，在该对象的内存存储中，所有父类定义的field都已经clone好了，该类中的primitive和不可变类型引用也克隆好了，可变类型引用都是浅copy。
3 把浅copy的引用指向原型对象新的克隆体。
给个例子。

class User implements Cloneable {String name;int age;@Overridepublic User clone() throws CloneNotSupportedException {return (User) super.clone();}}class Account implements Cloneable {User user;long balance;@Overridepublic Account clone() throws CloneNotSupportedException {Account account = null;account = (Account) super.clone();if (user != null) {account.user = user.clone();}return account;}}

对clone的态度

clone嘛，我觉得是个好东西，毕竟系统默认实现已经帮我们做了很多事情了。
但是它也是有缺点的。
1 手工维护clone的调用链。这个问题不大，程序员有责任做好。
2 如果class的field是个final的可变类，就不行了。三部曲的第三步没有办法做了。

考虑一个类对clone的态度，有如下几种。
1 公开支持：好吧，按照clone三部曲实现吧。前提是父类支持（公开或者默默）。
2 默默支持：不实现Cloneable接口，但是在类里面有正确的protected的clone实现，这样，该类不支持clone，但是它的子类如果想支持的话也不妨碍。
3 不支持：好吧，为了明确该目的，提供一个抛CloneNotSupportedException 异常的protected的clone实现。
4 看情况支持：该类内部可以保存其他类的实例，如果其他类支持则该类支持，如果其他类不支持，该类没有办法，只有不支持。

其他的选择

可以用原型构造函数，或者静态copy方法来手工制作一个对象的copy。
好处是即使class的field为final，也不会影响该方法的使用。不好的地方是所有的primitive赋值都得自己维护。

性能

不可否认，JVM越来越快了。
但是系统默认的native实现还是挺快的。
clone一个有100个元素的int数组，用系统默认的clone比静态copy方法快2倍左右。

原文地址：http://www.javaeye.com/topic/483469

补充：

我们也可以采用ObjectInputStream的方式来进行通用的深拷贝；

ByteArrayOutputStream bao = new ByteArrayOutputStream();ObjectOutputStream oo = new ObjectOutputStream(bao);oo.writeObject(this);ByteArrayInputStream bio = new ByteArrayInputStream(bao.toByteArray());ObjectInputStream ois = new ObjectInputStream(bio);return ois.readObject();

这是一个通用的深拷贝，但是不方便的是，必须利用Serializable接口；