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}

1. 实现Cloneable接口
2. 覆盖Object的clone()方法
3. 若要拷贝的对象只包含不可变类型的字段(包括final类型的类和内置类型)，只要调用super.clone()，即Object.clone()方法即可。
4. 若要拷贝的对象还包含可变类型的字段(例如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()方法。

转载于:https://www.cnblogs.com/universal/p/10415489.html