java中的深拷贝与浅拷贝

Java中深拷贝与浅拷贝

在谈论深拷贝、浅拷贝之前，首先要理解什么是值类型？什么是引用类型？这对于理解深拷贝、浅拷贝很关键。

在Java的世界，我们要习惯用引用去操作对象。在Java中，像数组、类Class、枚举Enum、Integer包装类等等，就是典型的引用类型，所以操作时一般来说采用的也是引用传递的方式；

但是Java中基础数据类型，如int这些基本类型，操作时一般采取的则是值传递的方式，所以有时候也称它为值类型。

---

为了方便案例的演示，首先准备两个类，一个是教师类，一个是学生类，这里以一个老师只教一个学生为例，教师类中包含自己所教的学生。

• 教师类，Teacher

public class Teacher {
	/**
	 * 姓名
	 */
	private String name;
	/**
	 * 年龄
	 */
	private int age;
	/**
	 * 学生
	 */
	private Student stu;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	......
}

• 学生类，Student

public class Student {
	/**
	 * 学号
	 */
	private long stuNo;
	/**
	 * 姓名
	 */
	private String stuName;

	public long getStuNo() {
		return stuNo;
	}

	public void setStuNo(long stuNo) {
		this.stuNo = stuNo;
	}
    ......
}

此时，这两个类的关系如下：

浅拷贝

浅拷贝，它的特性体现在这个“浅”字上面。

• 浅拷贝代码实现：

public class Teacher implements Cloneable{
	/**
	 * 姓名
	 */
	private String name;
	/**
	 * 年龄
	 */
	private int age;
	/**
	 * 学生
	 */
	private Student stu;

	@Override
	public Teacher clone() {
		try {
			return (Teacher) super.clone();
		} catch (CloneNotSupportedException e) {
			throw new AssertionError();
		}
	}
   	......
}

• 主程序

public class ShallowMain {
	public static void main(String[] args) {
		Student student = new Student(2016021006, "李四");
		Teacher teacher = new Teacher("鲁班", 24);
		teacher.setStu(student);

		// 克隆教师对象
		Teacher teacher1 = teacher.clone();

		System.out.println(teacher == teacher1);
		// 原对象
		System.out.println(teacher);
		// 克隆对象
		System.out.println(teacher1);

		System.out.println("-------------------修改克隆对象的name以及年龄---------------------");
		// 修改克隆对象的name以及年龄
		teacher1.setName("鲁班大师");
		teacher1.setAge(34);

		// 原对象
		System.out.println("原对象：" + teacher);
		// 克隆对象
		System.out.println("克隆对象：" + teacher1);

		System.out.println("-------------------修改原对象的学生属性---------------------");
		// 修改原对象的学生属性
		student.setStuName("张三");
		student.setStuNo(666666);

		// 原对象
		System.out.println("原对象：" + teacher);
		// 克隆对象
		System.out.println("克隆对象：" + teacher1);
	}
}

打印出的结果：

---

根据这里执行的结果得出结论:

• teacher == teacher1打印出的结果是false，则说明是创建了一个新的对象

• 修改克隆出的对象的name和age属性，发现并不会影响原对象的属性值

• 修改克隆出的对象的学生属性，导致原对象的学生属性也被修改了

浅拷贝中 值类型的字段会复制一份，而引用类型的字段拷贝的仅仅是引用地址，而该引用地址指向的实际对象空间其实只有一份。

---

（1）引出的问题，String类型是属于引用类型，为什么它也和基本数据类型一样是复制值？后面再研究这个问题

深拷贝

深拷贝相对于浅拷贝，在复制基本数据类型时，也会将引用类型所指向的内存拷贝一份。如下图。

• 深拷贝代码实现：

深拷贝需要本例中的Student也实现Cloneable接口，这样Student也可以拷贝。

• Student类

public class Student implements Cloneable{
	/**
	 * 学号
	 */
	private long stuNo;
	/**
	 * 姓名
	 */
	private String stuName;

	@Override
	public Student clone() {
		try {
			return (Student) super.clone();
		} catch (CloneNotSupportedException e) {
			throw new AssertionError();
		}
	}
	
	......
}

• Teacher类

public class Teacher implements Cloneable{
	/**
	 * 姓名
	 */
	private String name;
	/**
	 * 年龄
	 */
	private int age;
	/**
	 * 学生
	 */
	private Student stu;

	@Override
	public Teacher clone() {
		try {
            //先克隆Teacher对象
			Teacher teacher = (Teacher) super.clone();
            //克隆Student对象，复值给克隆出的teacher对象中的stu属性
			teacher.stu = stu.clone();
			return teacher;
		} catch (CloneNotSupportedException e) {
			throw new AssertionError();
		}
	}
	
	......
}

• 主程序类与浅拷贝主程序代码一致

• 执行结果

根据执行结果得出：克隆出的Teacher对象已经是相互独立的互不干扰。

---

深拷贝的另一种实现方式：反序列化实现对象深拷贝

• Teacher类

public class Teacher implements Serializable{
	/**
	 * 姓名
	 */
	private String name;
	/**
	 * 年龄
	 */
	private int age;
	/**
	 * 学生
	 */
	private Student stu;

	@Override
	public Teacher clone() {
		/*try {
			Teacher teacher = (Teacher) super.clone();
			teacher.stu = stu.clone();
			return teacher;
		} catch (CloneNotSupportedException e) {
			throw new AssertionError();
		}*/

		try {
			//将当前对象序列化到字节流
			ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
			ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
			objectOutputStream.writeObject(this);
			//反序列化创建对象
			ObjectInputStream objectInputStream = new ObjectInputStream(
					new ByteArrayInputStream(outputStream.toByteArray()));
			return  (Teacher) objectInputStream.readObject();
		} catch (IOException | ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
}

• 反序列创建对象，需要被引用的子类可以被序列化。也就是Student类需要实现Serializable接口。

public class Student implements Serializable {
	/**
	 * 学号
	 */
	private long stuNo;
	/**
	 * 姓名
	 */
	private String stuName;

	/*@Override
	public Student clone() {
		try {
			return (Student) super.clone();
		} catch (CloneNotSupportedException e) {
			throw new AssertionError();
		}
	}*/
}

• 主程序执行结果：

String引用类型

String常见的两种创建方式，示例代码：

public class StringMain {
	public static void main(String[] args) {
		String str1 = new String("Hello");
		String str2 = "Hello";
		System.out.println(str1 == str2); //false
	}
}

str2指向的是常量池中的Hello字符串

str1指向的是在堆内存中创建的String对象，内容是Hello字符串。

在java中String通过常量赋值认为是基本数据类型，通过new关键字创建的对象则是引用类型。