Java 深度克隆clone 对象的拷贝(深层复制)

关于克隆(Object[clone])

克隆，主要作用是将当前对象进行复制拷贝，保留原有对象持有的属性、状态。是来自Object类中的clone方法，被关键字native修饰，是非java语言实现的接口。首先看一下Object中的clone方法，如下：

为什么使用克隆？克隆的场景是什么？

当程序运行中时，需要A对象的相同属性、状态来生成新的对象B，B对象与A对象具有相同的属性、状态。而A对象会继续执行后续的业务，同时后续的业务中也使用B对象。

克隆的分类

Java中的克隆，主要分为两类：

1. 浅度克隆：只克隆对象的基本数据类型的属性，不会克隆引用类型的属性。当然，基本数据类型的包装类和String类型除外。
2. 深度克隆：克隆当前对象的所有持有属性(所有数据类型)。

克隆方式

1. 克隆对象的Class实现Cloneable接口

public class Student implements Cloneable {}

实现Cloneable接口后，方可使用Object中的clone方法。但是此方式只能克隆对象的基本数据类型(包括基本数据类型的包装类)和String类型的属性，属于浅度克隆。
如果要想通过此方式实现深度克隆，必须给克隆对象持有的引用类型的Class也实现Cloneable接口。代码如下：

Student类：

public class Student implements Cloneable {
	private int	stuId; // 学号
	private Teacher teacher; //持有Teacher对象
	// 克隆
	@Override
	public Object clone() throws CloneNotSupportedException {
		// 调用Object的clone方法,并强制转换为Student，得到新的Student对象stuClone
		Student stuClone = (Student)super.clone();
		// 从stuClone中获取teacher，这里的teacher并没有真正的实现克隆，只是持有引用。
		// 实际上，stuClone里的teacher引用指向的是原Student对象中teacher的内存堆地址。
		// 目前，原student对象与新的stuClone对象两者引用的Teacher是同一个Teacher对象。
		Teacher teacher = (Teacher)stuClone.getTeacher()
		// 现在，将从stuClone拿到的teacher对象再进行克隆，并将克隆到的teacherClone对象给stuClone
		Teacher teacherClone = teacher.clone();
		stuClone.setTeacher(teacherClone);
	}
	
	public Teacher getTeacher() {
		return teacher;
	}
	
	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}
}

Teacher类：

public class Teacher implements Cloneable {
	// 学科
	private String subject;
	// 克隆
	@Override
	public Object clone() throws CloneNotSupportedException {
		// 调用Object的clone方法
		Object obj = super.clone();
		return obj;
	}
	public String getSubject() {
		return subject;
	}
	
	public void setSubject(String subject) {
		this.subject = subject;
	}
}

小结： 实现Cloneable接口的方式，做浅度克隆还可以，但是要做深度克隆的话，需要手动地将对象的引用类型(基本数据类型的包装类和String类型除外)一个一个的克隆，维护起来很麻烦。本人不推荐使用。

2. 克隆对象的Class实现Serializable接口

public class Student implements Serializable {}

实现Serializable接口，利用序列化的方式实现克隆，这种方式是深度克隆。

其中原理：利用IO流方式，将对象写入流里，再从流里将对象读取出来（这一过程其实相当于复制拷贝）。实现Serializable的会将引用类型一并进行克隆。

为了方便，我这里使用了继承。父类:Person 子类:Student、Teacher。直接上代码：

Person类：

// 父类实现序列化接口Serializable，子类只需继承便可
public class Person implements Serializable {
	
	/** serialVersionUID */
	private static final long	serialVersionUID	= 1L;
	// 年龄
	private int					age;
	// 姓名
	private String				name;
	
	public Person() {}
	
	public Person(int age, String name) {
		this.age = age;
		this.name = name;
	}
	// 此方法是普通克隆方法
	public Person clone() {
		try {
			// 创建输出流，将对象放入流里
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.writeObject(this);
			// 创建输入流，将对象读出来
			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
			ObjectInputStream ois = new ObjectInputStream(bais);
			Person obj = (Person) ois.readObject();
			return obj;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	// 此方法是利用泛型的克隆方法，省去了最后的强制转换过程
	// 同时也限制了被克隆类的类型，必须继承Person
	public <T> T clone(Class<T> clazz) {
		try {
			// 如果目标类没有继承关系，可以将下面判断条件删除
			T newInstance = clazz.newInstance();
			if (!(newInstance instanceof Person)) {
				// 如果不是Person类型，抛异常
				throw new Exception("被clone的对象不属于基类Person类型");
			}
			// 创建输出流，将对象放入流里
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.writeObject(this);
			// 创建输入流，将对象读出来
			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
			ObjectInputStream ois = new ObjectInputStream(bais);
			Object readObject = ois.readObject();
			// 将对象转换为规定的泛型
			T obj = clazz.cast(readObject);
			return obj;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	
	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;
	}
	
}

Student类：

// 继承父类Person
public class Student extends Person {
	
	/** serialVersionUID */
	private static final long	serialVersionUID	= 1L;
	// 学号
	private int					stuId;
	// 持有应用类型Teacher对象
	private Teacher				teacher;
	
	public Student() {}
	
	public Student(int age, String name, int stuId) {
		super(age, name);
		this.stuId = stuId;
	}
	
	public int getStuId() {
		return stuId;
	}
	
	public void setStuId(int stuId) {
		this.stuId = stuId;
	}
	
	public Teacher getTeacher() {
		return teacher;
	}
	
	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}
	
	@Override
	public String toString() {
		return "Student [age=" + this.getAge()+ ",name=" + this.getName()+ ",stuId=" + stuId + ", teacher=" + teacher + "]";
	}
	
}

Teacher类：

public class Teacher extends Person {
	
	/** serialVersionUID */
	private static final long	serialVersionUID	= 1L;
	// 学科
	private String				subject;
	
	public Teacher() {
	}
	
	public Teacher(String subject) {
		this.subject = subject;
	}
	
	public String getSubject() {
		return subject;
	}
	
	public void setSubject(String subject) {
		this.subject = subject;
	}
	
	@Override
	public String toString() {
		return "Teacher [subject=" + subject + "]";
	}
	
}

测试：

public static void main(String[] args) {
		// 创建学生对象
		Student stu1 = new Student(10, "zhangsan", 1001);
		// 给学生安排一个体育老师
		stu1.setTeacher(new Teacher("体育"));
		System.out.println("学生：" + stu1.toString());
		// 克隆
		Student clone = stu1.clone(Student.class);
		System.out.println("克隆" + clone.toString());
		System.out.println("------------------修改后--------------------");
		// 修改克隆对象的属性
		clone.setAge(22);
		clone.setName("lisi");
		clone.setStuId(1002);
		clone.getTeacher().setSubject("语文");
		System.out.println("克隆对象：" + clone.toString());
		System.out.println("学生对象：" + stu1.toString());
	}

打印输出：

学生：Student [age=10,name=zhangsan,stuId=1001, teacher=Teacher [subject=体育]]
克隆：Student [age=10,name=zhangsan,stuId=1001, teacher=Teacher [subject=体育]]
------------------修改后--------------------
克隆对象：Student [age=22,name=lisi,stuId=1002, teacher=Teacher [subject=语文]]
学生对象：Student [age=10,name=zhangsan,stuId=1001, teacher=Teacher [subject=体育]]

可以看出，克隆之后修改了克隆对象的基本类型和引用类型的属性，被克隆对象的属性并没有做任何修改。这就是深度克隆。

总结：两种方式实现了对象的克隆，针对深度克隆而言，实现Serializable这种方式要比实现Cloneable方式简单方便的多，而且易维护。
推荐使用Serializable！

原创文章，有不足之处还请各路大神多多指点，多多包涵。
如需转载，请标明出处，不胜感激。
                                                                                                        —— 码上仙