一、浅复制与深复制的概念
1、浅复制
被复制的对象的所有变量都含有与原来对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
2、深复制
被复制对象的所有变量都含有与原来对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过得新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。
二、Java中对象的复制
1、Java的clone()方法（定义在Object类中）。
clone()方法将对象复制了一份并返回给调用者。一般而言，clone方法满足：
- 对任何对象，都有x.clone() != x;
说明：克隆对象与原对象不是同一个对象。 - 对任何的对象x，都有x.clone.getClass() == x.getClass();
说明：克隆对象与原对象类型一样。 - 如果对象x的equals方法定义恰当，那么x.clone().equals(x)应该成立。
2、Java中对象的克隆
（1）为了获取对象的一份拷贝，我们可以利用Object类的clone()方法；
（2）在派生类中覆盖基类的clone()方法，并声明为public（Object类中的clone方法为protected）；
（3）在派生类的的clone()方法中，调用super.clone()；
（4）在派生类中实现Cloneable接口。
3、说明
（1）为什么在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？
- 因为在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间。
（2）继承自java.lang.Object类的clone()方法是浅复制
4、CloneTest2示例
CloneTest2代码中展示了二-2中Java对象的克隆，其中第一个clone()方法(注释掉的代码)验证了继承自java.lang.Object类的clone()方法是浅复制。第二个clone()方法为修改后的深复制的代码。
public class CloneTest2
{
public static void main(String[] args) throws CloneNotSupportedException
{
Teacher teacher = new Teacher();
teacher.setAge(40);
teacher.setName("zhanglaoshi");
Student2 student2 = new Student2();
student2.setAge(15);
student2.setName("xiaoming");
student2.setTeacher(teacher);
Student2 s2 = student2.clone();
System.out.println(s2.getAge());
System.out.println(s2.getName());
teacher.setName("teacher lee");
System.out.println(student2.getTeacher().getName());
System.out.println(s2.getTeacher().getName());
}
}
class Teacher implements Cloneable
{
int age;
String 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;
}
@Override
public Object clone() throws CloneNotSupportedException
{
Object object = super.clone();
return object;
}
}
class Student2 implements Cloneable
{
int age;
String name;
Teacher teacher;
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 Teacher getTeacher()
{
return teacher;
}
public void setTeacher(Teacher teacher)
{
this.teacher = teacher;
}
//继承自java.lang.Object类的clone()方法是浅复制
// @Override
// public Object clone() throws CloneNotSupportedException
// {
// Object object = super.clone();
// return object;
// }
//实现深复制
@Override
public Student2 clone() throws CloneNotSupportedException
{
//先进行浅复制
Student2 student2 = (Student2)super.clone();
//再将要复制对象中所引用的对复制一遍
student2.setTeacher((Teacher)student2.getTeacher().clone());
return student2;
}
}
-
用第一个clone()方法时，当修改了teacher的名字时，会发现我们复制的student对象中teacher的名字也跟着变了。验证了继承自java.lang.Object类的clone()方法是浅复制。程序执行结果如下：
image.png -
用第二个clone()方法时，当修改了teacher的名字时，会发现我们复制的student对象中teacher的名字没有跟着变。验证实现了深复制。运行结果如下：
image.png
三、利用序列化来做深复制
1、序列化与反序列化
把对象写到流里的过程是序列化（Serialization）过程，而把对象从流中读出来的过程则叫做反序列化（Deserialization）过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM中。
2、利用序列化来做深复制
在Java语言中深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。
3、两点说明
- 这样做的前提是对象以及对象内部所有引用到的对象是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。
- Cloneable和Seriable都是Marker Interface，也就是说它们只是一个标识接口，没有定义任何方法。
4、CloneTest3示例用序列化实现了深复制
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class CloneTest3
{
public static void main(String[] args) throws ClassNotFoundException, IOException
{
Teacher3 teacher3 = new Teacher3();
teacher3.setAge(40);
teacher3.setName("Teacher zhang");
Student3 s1 = new Student3();
s1.setAge(16);
s1.setName("xiaoming");
s1.setTeacher(teacher3);
Student3 s2 = (Student3)s1.deepClone();
System.out.println(s2.getAge());
System.out.println(s2.getName());
System.out.println(s2.getTeacher().getName());
teacher3.setName("hahahha");
System.out.println(s1.getTeacher().getName());
System.out.println(s2.getTeacher().getName());
}
}
class Teacher3 implements Serializable
{
private static final long serialVersionUID = 2456812179890003332L;
private int age;
private String 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;
}
}
class Student3 implements Serializable
{
private static final long serialVersionUID = 3565617956555242115L;
private int age;
private String name;
private Teacher3 teacher;
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 Teacher3 getTeacher()
{
return teacher;
}
public void setTeacher(Teacher3 teacher)
{
this.teacher = teacher;
}
public Object deepClone() throws IOException, ClassNotFoundException
{
/**
* 使用ObjectOutputStream将对象序列化到字节数组节点流
*/
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
/**
* 使用ObjectInputStream将对象从字节数组节点流取出并恢复（反序列化）
*/
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
}
-
当改变了teacher3的name属性值后，运行程序，发现只有s1对象中teacher中的name属性值改变，复制得到的s2对象中teacher的name属性值并为改变。验证深拷贝实现成功。
image.png
