Java clone、浅复制、深复制、复制构造函数

在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);
		}
	}

### 回答1: 在Java中,拷贝构造函数并不像C++中那样直接支持。但我们可以通过实现一个类的 clone() 方法来实现拷贝构造函数的功能。clone() 方法是 Java 中提供的一种拷贝(Shallow Copy)的方法,它可以用于创建一个对象的拷贝。 下面是一个示例代码,演示了如何实现一个拷贝构造函数: ``` public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } // 拷贝构造函数 public Person(Person another) { this.name = another.name; this.age = another.age; } // clone() 方法 public Person clone() { try { return (Person) super.clone(); } catch (CloneNotSupportedException e) { // 如果类没有实现 Cloneable 接口,则会抛出该异常 return null; } } } ``` 在上面的代码中,我们定义了一个 Person 类,并实现了一个拷贝构造函数拷贝构造函数接受一个 Person 类型的参数,用于创建一个新的 Person 对象,该对象与传入的参数对象具有相同的属性值。 此外,我们还实现了 clone() 方法,该方法可以用于创建一个 Person 对象的拷贝。在该方法中,我们调用了 Object 类中的 clone() 方法,并将其返回类型转换为 Person 类型。 需要注意的是,clone() 方法是 Object 类中的方法,如果需要使用该方法,必须在 Person 类中实现 Cloneable 接口。如果没有实现该接口,则在调用 clone() 方法时会抛出 CloneNotSupportedException 异常。 ### 回答2: 在Java中,拷贝构造函数是一种特殊的构造函数,它用于创建一个对象的副本。拷贝构造函数允许我们将一个对象的值复制到另一个对象中,而不是仅仅复制其引用。这在需要克隆或复制对象时非常有用。 要创建一个拷贝构造函数,我们需要在类中定义一个与类名相同的方法,并传入一个参数为该类的对象。例如,假设我们有一个名为Person的类,其中包含name和age两个属性。 public class Person { private String name; private int age; public Person(Person other) { this.name = other.name; this.age = other.age; } } 在上面的例子中,我们创建了一个在类中定义的拷贝构造函数。在该函数中,我们使用另一个Person对象的属性值来初始化新对象的属性。这样一来,我们就可以通过传递一个现有的Person对象来创建一个新的Person对象。 使用拷贝构造函数有几个好处。首先,它允许我们创建一个新对象,该对象与现有对象具有相同的属性值。这对于不修改现有对象但需要创建新对象的情况非常有用。其次,它避免了拷贝(只复制引用而不复制实际值)可能导致的问题。 在Java中,拷贝构造函数的使用是可选的。如果我们不定义一个拷贝构造函数Java默认提供一个拷贝的拷贝构造函数。但是,如果我们需要执行拷贝(复制对象及其所有子对象的值),就需要自己定义拷贝构造函数。 总之,拷贝构造函数是在Java中创建一个对象副本的一种特殊函数。它允许我们通过将一个对象的属性值复制到另一个对象中来创建新对象。这在复制、克隆对象或创建新对象时非常有用。 ### 回答3: 在Java中,拷贝构造函数是一种特殊的构造函数,用于创建一个新对象,该对象的内容与现有对象相同。拷贝构造函数的主要作用是复制一个对象的值到另一个新的对象中。 在Java中,拷贝构造函数的定义如下: public class MyClass { private int myInt; // 拷贝构造函数 public MyClass(MyClass obj) { this.myInt = obj.myInt; } // 构造函数 public MyClass(int myInt) { this.myInt = myInt; } // Getter和Setter方法 public int getMyInt() { return myInt; } public void setMyInt(int myInt) { this.myInt = myInt; } } 在上面的示例中,我们定义了一个名为MyClass的类,该类具有一个整型成员变量myInt。我们使用两个构造函数来创建对象,一个是拷贝构造函数,一个是普通构造函数拷贝构造函数的参数类型是与该类相同的对象,通过该参数将现有对象的值复制到新对象中。在拷贝构造函数中,我们可以使用this关键字引用当前对象,使用点操作符(.)访问对象的成员变量。 使用拷贝构造函数创建对象的示例代码如下: MyClass obj1 = new MyClass(10); // 使用普通构造函数创建对象 MyClass obj2 = new MyClass(obj1); // 使用拷贝构造函数创建对象 System.out.println(obj1.getMyInt()); // 输出:10 System.out.println(obj2.getMyInt()); // 输出:10 通过以上代码,我们可以看到obj2对象中的myInt值与obj1对象中的myInt值相同,这是因为拷贝构造函数将obj1对象的值复制给了obj2对象。 总之,拷贝构造函数是一种创建一个新对象并复制现有对象值的常用技术,它在Java中的定义和使用方法如上所述。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值