在java中的对象重复利用通常有两种渠道:复制引用、克隆,不管何种方法,它们都是为了减少对象重复创建和赋值操作,一定程度上提高效率。这里就有关对象复用的几种方式和关系进行探讨。
共识
java中的对象分为两派:值类型和引用类型,这是因为他们的传递方式,一个是值传递,一个是引用传递。
对于值类型,因为是值传递,所以在使用值类型的时候无须考虑引用类型存在一些问题,如:equals,hashcode,nullpoint,而在这里关键无须考虑的问题是:复制问题。诸如y = 1;x=y,y=2这些happend-befored,值类型的值是不受过去和将来影响的。
而对于引用类型就没这么轻松了,大家也有目共睹,于是在复制问题上,就有了题目中列出的方式。
Clone
User u1 = new User(“”,“”,“”,“”)
User u1 = new User(“”,“”,“”,“”)
像上面这种拙劣的对象创建方式,是我们不希望看到的。JAVA提供了对象克隆方法,这个是Object类的本地方法,利用克隆可以快速高效的复制一个对象而无需重新创建:
public class User implements Cloneable{
String name = "origin";
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Test
public void testClone() throws CloneNotSupportedException {
User u1 = new User();
User u2 = (User) u1.clone();
System.out.println(u1.hashCode());
System.out.println(u1.name);
u1.name = "origin2";
System.out.println(u2.hashCode());
System.out.println(u2.name);
}
输出:
1607460018
origin
48612937
origin
可以看出,克隆会创建出一个新的对象,对象的成员具有原始对象的信息,并且成员都是新的内存分配。要使用clone方法,必需实现Cloneable接口,该接口意义和serializable类似,然后重写Object的clone方法并调用super的本地方法。
浅复制
不过这看起来似乎挺美好的背后,并不是如你所想的那样,我们给user加一个复合引用类型的Inner:
public class User implements Cloneable{
String name = "origin";
Inner inner;
public User() {
inner = new Inner();
inner.name = "inner-origin";
}
这个Inner类同样持有一些引用类型的成员:
public class Inner{
String name;
}
@Test
public void testClone() throws CloneNotSupportedException {
User u1 = new User();
User u2 = (User) u1.clone();
System.out.println(u1.hashCode());
System.out.println(u1.name);
System.out.println(u1.inner.name);
u1.name = "origin2";
u1.inner.name = "innerorigin2";
System.out.println(u2.hashCode());
System.out.println(u2.name);
System.out.println(u2.inner.name);
输出:
1607460018
origin
inner-origin
48612937
origin
innerorigin2
显然:如果成员是另一个复合类型的引用,那么这个成员还是受到happend-before影响,也就是说,使用clone只能做到表面功夫,无法对更深层的引用进行内存层面上的复制,因此,这种复制方式被称为:浅复制。
深复制
深复制应该就是相对于浅复制,实现一个对象由外到内的全面克隆。如何做到深复制,java不像C语言那样可以通过operator操作来进行值拷贝,因此没有办法做到绝对意义上的深复制,可以说是没有这个概念。那么,这里说的深复制是在一定前提下进行的,就可以达到深复制的效果。
深复制方式1:对象序列化反序列化
public class User implements Cloneable,Serializable{
String name = "origin";
Inner inner;
public User() {
inner = new Inner();
inner.name = "inner-origin";
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public Object deepCopy(User u) throws IOException, ClassNotFoundException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeObject(u);
InputStream in = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream ois = new ObjectInputStream(in);
return ois.readObject();
}
同时,要求引用类型的成员也要实现序列化接口:
public class Inner implements Serializable{
String name;
}
public class TestClone {
@Test
public void testClone() throws CloneNotSupportedException, ClassNotFoundException, IOException {
User u1 = new User();
User u2 = (User) u1.clone();
User u3 = (User) u1.deepCopy(u1);
u1.name = "origin2";
u1.inner.name = "innerorigin2";
System.out.println(u1.hashCode());
System.out.println(u1.inner.hashCode());
System.out.println(u1.name);
System.out.println(u1.inner.name);
// System.out.println(u2.hashCode());
// System.out.println(u2.name);
// System.out.println(u2.inner.name);
System.out.println(u3.hashCode());
System.out.println(u3.inner.hashCode());
System.out.println(u3.name);
System.out.println(u3.inner.name);
}
输出:
1607460018
1811075214
origin2
innerorigin2
48612937
325333723
origin
inner-origin
可以看到深复制的目的已经达成,因为通过序列化和反序列化将分配新的内存创建对象和成员,所以这种做法是有效的,然而效率却很低下,毕竟不能称为复制,只是一种婉转曲折的传输方式,比较取巧,但是一些ORM框架仍然不得不采用这种做法,导致效率低下。
深复制方式2:复制函数
观察这两个User的构造函数有什么不同?
public User(String name,Inner inner) {
this.name = name;
this.inner = inner;
}
public User(User user) {
this.name = user.name;
this.inner = new Inner();
inner.name = user.inner.name;
}
第一个是有参的构造函数,第二个是用于复制的构造函数,所以也称为复制构造函数,用于从一个相同类型的对象中复制成员变量。这个例子就不测试了,相信你也能看出,其实就是多了一道工序来创建新的成员变量inner,而不是引用原来的inner对象,效率自然会比序列化和反序列化要高,只不过深度有限,不能保证复制深度范围外的对象深复制。如果你确定成员中的引用类型也能保证(或不需要关心)不变性,那么就可以通这种方式做一个不完全的深复制,在效率和深度上做一个平衡。
效率
下面做了一个简单的测试,可以看出浅复制和深复制的差距:
@Test
public void testCopy() throws CloneNotSupportedException {
for(int i=0;i<100000;i++) {
User u1 = new User();
User u2 = (User) u1.clone();
}
}
@Test
public void testDeepCopy() throws CloneNotSupportedException, ClassNotFoundException, IOException {
for(int i=0;i<100000;i++) {
User u1 = new User();
User u3 = (User) u1.deepCopy(u1);
}
}
@Test
public void testDeepCopyByConstructor() {
for(int i=0;i<100000;i++) {
User u1 = new User();
User u3 = new User(u1);
}
}