Java的clone与深拷贝、浅拷贝

最新推荐文章于 2024-03-03 08:30:00 发布

没头脑遇到不高兴

最新推荐文章于 2024-03-03 08:30:00 发布

阅读量841

点赞数 2

分类专栏： Java 文章标签： Java的clone与深拷贝、浅拷贝

本文链接：https://blog.csdn.net/u012988901/article/details/98503843

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java创建对象的四种方式

java创建对象的方式有如下四种：

new的方式 Object o=new Object();
使用clone()方法
使用反射的方式 Hello o=(Hello)Class.forName("com.test.Hello").getConstructor().newInstance();
要实现实现Serializable接口，将一个对象序列化到磁盘上，而采用反序列化可以将磁盘上的对象信息转化到内存中

我们这里重点说一下new和clone。在我们执行new对象的时候，会现根据对象的类型分配内存空间，然后调用构造方法初始化对象内的属性，初始化完成后构造方法返回，对象创建完成，可以将对象的引用发布到外部。clone更准确来说是复制一个原来已经存在的对象，而这个复制过程是直接操作的字节码，并不会执行构造方法，所以速度更快。

Java中的引用复制

上面我们提到了clone()方法可以复制对象，我们在开发过程中也经常会写类似于下面的代码：

Person a=new Person(20,"张三");
Person b=a;

其实上面的b=a的代码复制的并不是对象，而是将对象的引用地址复制给了b，a和b实际上对应的还是同一个对象

我们看下下面的测试代码：

public class Person{

	private int age;
	private String name;
	
	public Person(int age, String name) {
		this.age = age;
		this.name = name;
	}

	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public static void main(String[] args) {
		Person a = new Person(20,"张三");
		Person b=a;
		System.out.println(a);
		System.out.println(b);
		System.out.println(b.getName());
		a.setName("张小三");
		System.out.println(b.getName());
	}
}

输出结果如下所示：可以看到打印出来a,b对象的地址是相同的，当修改了a的name属性后，b的name属性也改变了，这也印证了两者指向同一个对象的说法。

com.wkp.designpattern.prototype.clone.Person@15db9742
com.wkp.designpattern.prototype.clone.Person@15db9742
张三
张小三

Java中对象复制（拷贝）

Java中的对象复制也叫对象拷贝，Java中的对象拷贝主要分为：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)。

浅拷贝：对象中的成员变量如果是8种基本类型（byte、short、int、long、float、double、boolean、char），则会将其值复制给新对象中对应的变量；如果是对象、数组等引用数据类型时，只会将该变量的引用复制到新对象中，这时如果修改该变量的值，则另一个对象的相同变量的值也会跟着变动。

String类型非常特殊，其属于引用数据类型，但是String类型的数据是存放在常量池中的，也就是无法修改的！下面例子代码中c="cccc"，并不是修改了这个对象的值，而是把这个对象的引用从指向"c"这个常量改为了指向”cccc“这个常量。在这种情况下，变量d的值是不受影响的，所以String类型的变量在克隆过程的复制效果是跟基本数据类型相同的。

String c="c";
String d=c;
System.out.println(d);
c="cccc";
System.out.println(d);

深拷贝：深拷贝不光复制基本数据类型的值，还会对每一个引用变量对象开辟新的内存空间，然后将变量的值复制到该内存空间中，如果该变量对象中也包含引用变量，也会开辟新的内存空间去存储变量的值，以此类推，直到所有的引用对象都复制到了新开辟的内存空间中。

假如有个Person类，其中包含age，name，car三个成员变量

public class Person{

	private int age;
	private String name;
	private Car car;
    ......
}

下面图中大致画了一下浅拷贝的示意图（String类型的name没有画，在String常量池中属于同一个对象），我们看到虽然a和b都指向了新的对象，但是对象中包含的引用变量car仍然指向的是同一个对象，如果修改a中的car对象，则b也会跟着变动。

下面是深拷贝的示意图，可以看到两个引用类型的变量car也都指向了不同的对象，这样改动car对象也不会相互影响了。如果car对象中也包含引用类型的变量，也是同意的方式处理。

通过重新clone方法实现浅拷贝

Object类是类结构的根类，其中有一个方法为protected Object clone() throws CloneNotSupportedException，这个方法就是进行的浅拷贝。有了这个浅拷贝模板，我们可以通过调用clone()方法来实现对象的浅拷贝。但是需要注意：1、Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。2、使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。对于这两点，我们的解决方法是，在要使用clone方法的类中重写clone()方法，通过super.clone()调用Object类中的原clone方法。

具体实现代码如下：下面是一个Car类

public class Car {
	
	private int price;
	private String name;
	public Car(int price, String name) {
		super();
		this.price = price;
		this.name = name;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

下面是一个Person类，其实现了Cloneable接口，并且重写了clone方法来实现对person对象的浅拷贝

public class Person implements Cloneable{

	private int age;
	private String name;
	private Car car;
	
	public Person(int age, String name,Car car) {
		this.age = age;
		this.name = name;
		this.car=car;
	}

	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Car getCar() {
		return car;
	}
	public void setCar(Car car) {
		this.car = car;
	}

	//浅克隆
	@Override
	protected Person clone() throws CloneNotSupportedException {
		return (Person) super.clone();
	}

}

下面是测试代码：

public class TestSimpleCopy {

	public static void main(String[] args) throws CloneNotSupportedException {
		Car car=new Car(100, "宝马");
		Person p1 = new Person(30, "张三", car);
		Person p2 = p1.clone();
		System.out.println(p1==p2);
		System.out.println(p1.getCar()==p2.getCar());
		p1.setName("张小三");
		System.out.println("p1 name:"+p1.getName());
		System.out.println("p2 name:"+p2.getName());
	}
}

输出结果如下：

p1，p2两者的引用是不同的，也就是两者指向不同的内存地址
p1中的car成员变量跟p2中的成员变量的引用相同，说明只是拷贝的引用，并不是拷贝的对象
修改了p1的string类型的变量值，p2的对应的变量值不变

false
true
p1 name:张小三
p2 name:张三

通过重写clone方法实现深拷贝

上面重写clone方法实现了浅拷贝，要想实现深拷贝则需要对象中所有引用类型对象都重新clone方法，比如a对象中包含引用类型的b，b中又包含引用类型的c。。。。。。则a、b、c都需要实现clone方法，就是每一级引用都实现了浅拷贝，那就实现了深拷贝。

修改后的Car类代码如下（省略了set，get方法）：重新了clone方法

public class Car implements Cloneable{
	
	private int price;
	private String name;
	public Car(int price, String name) {
		super();
		this.price = price;
		this.name = name;
	}
	
	@Override
	protected Car clone() throws CloneNotSupportedException {
		return (Car) super.clone();
	}
}

修改后的Person类代码如下（省略了set，get方法）：在clone方法中，添加了对car对象的clone

public class Person implements Cloneable{

	private int age;
	private String name;
	private Car car;
	
	public Person(int age, String name,Car car) {
		this.age = age;
		this.name = name;
		this.car=car;
	}


	//所有下级的引用类型对象都重新clone方法来实现深拷贝
	@Override
	protected Person clone() throws CloneNotSupportedException {
		Person p= (Person) super.clone();
		p.car=this.car.clone();
		return p;
	}

}

测试代码如下：

public class TestCloneDeepCopy {

	public static void main(String[] args) throws CloneNotSupportedException {
		Car car=new Car(100, "宝马");
		Person p1 = new Person(30, "张三", car);
		Person p2 = p1.clone();
		System.out.println(p1==p2);
		System.out.println(p1.getCar()==p2.getCar());
	}
}

输出结果如下：两者引用地址都不相同，可见已经实现了深拷贝

false
false

这种方式虽然也可以实现深拷贝但是并不太好，因为如果引用层级特别多的话，每一级都要重写clone方法，如果是我们自己写的类还好说可以改一改，但如果是第三方类库我们是没法改的。

通过序列化实现深拷贝

将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。

注意：对象的所有引用类型的变量都要实现Serializable接口，否则会报java.io.NotSerializableException异常，在本例中如果Car这个类中有其他引用类型变量，其也要实现序列化接口；如果某个属性被transient修饰，那么该属性无法被序列化，也就无法被拷贝了。

修改后的Car类代码如下（省略了set，get方法）：实现了Serializable接口

public class Car implements Serializable{
	
	private int price;
	private String name;
	public Car(int price, String name) {
		super();
		this.price = price;
		this.name = name;
	}

}

修改后的Person类代码如下（省略了set，get方法）：添加了一个copy方法，通过序列化的方式实现深拷贝

public class Person implements  Serializable {

	private int age;
	private String name;
	private Car car;

	public Person(int age, String name, Car car) {
		this.age = age;
		this.name = name;
		this.car = car;
	}

	//通过序列化反序列化实现深度克隆
	public Person copy() {
		ByteArrayOutputStream bos = null;
		ObjectOutputStream oos = null;
		ByteArrayInputStream bis = null;
		ObjectInputStream ois = null;
		try {
			// 序列化
			bos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(bos);
			oos.writeObject(this);

			// 反序列化
			bis = new ByteArrayInputStream(bos.toByteArray());
			ois = new ObjectInputStream(bis);
			Person copy = (Person) ois.readObject();

			return copy;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			try {
				bos.close();
				oos.close();
				bis.close();
				ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

测试代码如下：

public class TestSerializeDeepCopy {

	public static void main(String[] args) throws CloneNotSupportedException {
		Car car=new Car(100, "宝马");
		Person p1 = new Person(30, "张三", car);
		Person p2 = p1.copy();
		System.out.println(p1==p2);
		System.out.println(p1.getCar()==p2.getCar());
	}
}

输出结果如下：两者引用地址都不相同，可见已经实现了深拷贝

false
false

没头脑遇到不高兴

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java的clone与深拷贝、浅拷贝

Java创建对象的四种方式java创建对象的方式有如下四种：new的方式 Object o=new Object(); 使用clone()方法使用反射的方式 Hello o=(Hello)Class.forName("com.test.Hello").getConstructor().newInstance(); 要实现实现Serializable接口，将一个对象序列化到磁盘上，而...
复制链接

扫一扫