java 对象拷贝_Java对象拷贝

Java对象拷贝分为浅拷贝(shadow copy )和深拷贝(deep copy)。

浅拷贝：被复制对象的任何变量都含有和原来的对象相同的值，而任何的对其他对象的引用仍然指向原来的对象。对拷贝后的引用的修改，还能影响原来的对象。

深拷贝：把要复制的对象所引用的对象都复制了一遍，对现在对象的修改不会影响原有的对象。

首先，新建一个Employee类，包含一个String类型的姓名，一个double类型的工资，一个Date类型的雇佣日期。

public class Employee implements Cloneable{

private String name;

private double salary;

private Date hireDay = new Date();

public Employee(String name, double salary) {

this.name = name;

this.salary = salary;

}

public void setName(String name){

this.name = name;

}

public void setHireDay(int year,int month,int day){

Date newHireDay = new GregorianCalendar(year,month-1,day).getTime();

hireDay.setTime(newHireDay.getTime());

}

public void raiseSalary(double byPercent){

double raise = salary * byPercent / 100;

salary += raise;

}

@Override

public String toString() {

return "Employee{" +

"name='" + name + '\'' +

", salary=" + salary +

", hireDay=" + hireDay +

'}';

}

@Override

public Employee clone() throws CloneNotSupportedException{

//call Object.clone()

Employee clone = (Employee) super.clone();

//clone mutable fields

clone.hireDay = (Date) hireDay.clone();

return clone;

}

public Employee shadowClone() throws CloneNotSupportedException {

return (Employee) super.clone();

}

}

public class CloneTest {

public static void main(String[] args) {

try{

Employee original = new Employee("John Q. Public",50000);

original.setHireDay(2018,4,1);

Employee shadowCopy = original.shadowClone();

shadowCopy.setName("Mike");

shadowCopy.raiseSalary(10);

shadowCopy.setHireDay(2018,4,2);

Employee copy = original.clone();

copy.setName("Jason");

copy.raiseSalary(10);

copy.setHireDay(2018,4,2);

System.out.println("original=" + original);

System.out.println("shadowCopy=" + shadowCopy);

System.out.println("copy=" + copy);

} catch (CloneNotSupportedException e) {

e.printStackTrace();

}

}

}

//输出结果

//original=Employee{name='John Q. Public', salary=50000.0, hireDay=Mon Apr 02 00:00:00 CST 2018}

//shadowCopy=Employee{name='Mike', salary=55000.0, hireDay=Mon Apr 02 00:00:00 CST 2018}

//copy=Employee{name='Jason', salary=55000.0, hireDay=Mon Apr 02 00:00:00 CST 2018}

实现Cloneable接口

覆盖Object的clone()方法

若要拷贝的对象只包含不可变类型的字段(包括final类型的类和内置类型)，只要调用super.clone()，即Object.clone()方法即可。

若要拷贝的对象还包含可变类型的字段(例如Date类型)，就需要递归对子对象进行拷贝。

Employee对象拷贝在内存中的引用关系如下图:

{% qnimg Employee对象引用关系图.jpg title:Employee对象引用关系图 alt:Employee对象引用关系图 'class:' extend:? imageView2/2/w/450 %}

如图，由于Employee对象的name字段是String类型的，在内存中不可变的，所以只要调用Object.clone()方法，返回新的拷贝对象后，若对新的对象改变name，将会重新在内存中分配一个String对象来存储name。而对于可变类型hireDay，若只是浅拷贝，新的拷贝对象将只是拷贝一个指向原来hireDay子对象的一个引用，改变新的拷贝对象的hireDay，将会导致原来对象的hireDay也跟着改变。如果在clone方法中对子对象hireDay进行递归clone的话，就可以避免此问题。

对于集合对象，比如ArrayList，Java集合的拷贝构造函数只提供浅拷贝而不是深拷贝，这意味着存储在原始List和克隆List中的对象是相同的，指向Java堆内存中相同的位置。所以如果要深拷贝需要调用ArrayList.addAll()方法。