Java中深拷贝(Deep Clone)与浅拷贝(Shallow Clone)

我们先从理论上讨论浅拷贝：

java的类型分为两大类，一类为primitive，如int等8种，另一类为引用类型,如String,Object等等。java的引用类型都是存储在堆上的。

java的浅复制在复制时，对于原始类型的变量，在堆上为其分配一块区间，对于引用类型，在堆上为其对象的引用分配一块区间，这样得到的实际效果是：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象，即当对其他对象的引用进行改变时，改变的是对象的值，被复制的引用值也发生了变化。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

实例代码如下：

public class CloneTest1
{
public static void main(String[] args) throws Throwable
{
Teacher teacher = new Teacher();

teacher.setAge(34);
teacher.setName("Teacher chen");

Student student = new Student();

student.setAge(20);
student.setName("zhangsan");
student.setTeacher(teacher);

//clone方法返回的是Object类型的对象，即会生成新的对象
Student student2 = (Student)student.clone();

System.out.println(student2.getAge());
System.out.println(student2.getName());
System.out.println(student2.getTeacher().getAge());
System.out.println(student2.getTeacher().getName());

System.out.println("----------------------------------");

/**
* 以下几行说明clone是浅复制(只是复制引用)，即复制后两个对象中的teacher属性都指向同一个对象，
* 如果把拷贝的对象的teacher属性重新设置，则会影响被拷贝的对象。
*/
student2.getTeacher().setName("hello world");
student2.getTeacher().setAge(44);
student2.setName("lisi");//不会改变student的属性

System.out.println(student2.getAge());
System.out.println(student2.getName());
//student2中的teacher对象也发生了改变
System.out.println(student2.getTeacher().getAge());
System.out.println(student2.getTeacher().getName());

System.out.println("----------------------------------");

System.out.println(student.getAge());
System.out.println(student.getName());
System.out.println(student.getTeacher().getAge());
System.out.println(student.getTeacher().getName());
}
}

class Student implements Cloneable
{
private int age;

private String name;

private Teacher teacher;

public Teacher getTeacher()
{
return teacher;
}

public void setTeacher(Teacher teacher)
{
this.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;
}

@Override
protected Object clone() throws CloneNotSupportedException
{
Object object = super.clone();

return object;
}
}

class Teacher implements Cloneable
{
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;
}
}

再来看看深拷贝：

理论上，深复制对原始类型的操作与浅复制一样，对于引用类型，其既对对象的引用进行复制，也对对象本身进行复制，这样得到的实际效果是：当复制的引用值发生变化时，被复制的引用值没有发生变化，实现了深复制。被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

实例代码如下：

//深复制
public class CloneTest2
{
public static void main(String[] args) throws Throwable
{
Teacher2 teacher = new Teacher2();

teacher.setAge(40);
teacher.setName("Teacher zhang");

Student2 s1 = new Student2();

s1.setAge(20);
s1.setName("zhangsan");
s1.setTeacher(teacher);

Student2 s2 = (Student2)s1.clone();

System.out.println(s2.getName());
System.out.println(s2.getAge());

/**
* 因为下面Student2中的clone方法也实现了对Teacher对象的拷贝，
* 所以在s2中已经拥有了新的Teacher对象，不再是前面传给s1的那个Teacher对象，
* 故下面这句只是改变了s1中的那个Teacher对象，而不会改变s2中的那个Teacher对象。
*/
teacher.setName("Teacher li");

System.out.println(s1.getTeacher().getName());
System.out.println(s1.getTeacher().getAge());

System.out.println(s2.getTeacher().getName());
System.out.println(s2.getTeacher().getAge());
}
}

class Teacher2 implements Cloneable
{
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;
}

//只是为了在其他类中可以调用Teacher中的这个clone方法，所以重写为public
@Override
public Object clone() throws CloneNotSupportedException
{
return super.clone();
}
}

class Student2 implements Cloneable
{
private int age;

private String name;

private Teacher2 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 Teacher2 getTeacher()
{
return teacher;
}

public void setTeacher(Teacher2 teacher)
{
this.teacher = teacher;
}

@Override
public Object clone() throws CloneNotSupportedException
{
Student2 student2 = (Student2)super.clone();

//把Teacher对象也复制一份，相当于有两个Teacher对象了
student2.setTeacher((Teacher2)student2.getTeacher().clone());

return student2;

//下面这种方法只能实现浅复制
//		Object object = super.clone();
//
//		return object;
}
}

一言以蔽之：浅复制只是简单的值传递（这样一来复制的双方可能有瓜葛），而深复制则是深层次的对象传递（这样一来复制的双方不会有作何瓜葛），这里的对象传递指的是若有引用的复制则生成新的对象，而不会只是单纯地将引用指向原来的对象。

参考文献：http://java.chinaitlab.com/oop/716567.html