java对象拷贝和复制

参考文章：http://blog.csdn.net/XIAXIA__/article/details/41652057

解决问题：深拷贝、浅拷贝 和普通的对象赋值有什么区别？

对象复制

例如：Person p2 = p1;实质就是对象地址复制。把p1地址赋值给p2。此时二者同时指向一块堆内存，所以改变p1的属性值之后，p2所对应的属性值也会跟着变化。

例如有一个如下所示的Person类：

 package tudou.javabasic.clone;

 class Person {
     private int age;
     private String name;
     private Address address;

     public Address getAddress() {
         return address;
     }

     public void setAddress(Address address) {
         this.address = address;
     }

     public Person(int age, String name) {
         this.age = age;
         this.name = 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 String toString() {
         return "Person{" +
                 "age=" + age +
                 ", name='" + name + '\'' +
                 '}';
     }
 }

Person

执行如下代码：

 public class CloneTest {
     public static void main(String[] args) {
         Person p1 = new Person(1, "first");
         Person p2 = p1;//把p1的引用赋值给p2
         System.out.println("p2.name before:"+p2.getName());
         p1.setName("second");
         System.out.println("p2.name after:"+p2.getName());
     }
 }

CloneTest

输出结果为：

p2.name before:first
p2.name after:second

如果在改变p1的值之后不想改变p2的值，应该如何处理呢？这时候需要用到拷贝，拷贝用到的函数为object的clone()方法

深拷贝和浅拷贝

clone()方法：

创建一个新对象，然后将当前对象的非静态字段复制到该新对象，

如果字段是值类型的，那么对该字段执行复制；

如果该字段是引用类型的话，则复制引用但不复制引用的对象。（这个称为浅拷贝）

原始对象及其副本引用同一个对象。

这个也就是说：如果使用clone()方法，对于值类型直接复制，对于引用类型 则还是采用复制 引用地址的方式。

代码如下：

 package tudou.javabasic.clone;

 /**
  * Created by tudou on 2017-02-22.
  * 浅拷贝
  */
 public class ShallowCopyPerson implements Cloneable {
     private int age;
     private String name;
     private Address address;

     public ShallowCopyPerson(int age, String name, Address address) {
         this.age = age;
         this.name = name;
         this.address = address;
     }
     public Object clone() {
         try {
             return (ShallowCopyPerson)super.clone();
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }
     }

     public Address getAddress() {
         return address;
     }

     public void setAddress(Address address) {
         this.address = address;
     }

     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 String toString() {
         return "ShallowCopyPerson{" +
                 "age=" + age +
                 ", name='" + name + '\'' +
                 ", address=" + address +
                 '}';
     }
 }

ShallowCopyPerson

ShallowCopyPerson 类扩展Cloneable接口，重点关注的方法是clone()方法，这里只是简单使用：

 public Object clone() {
         try {
             return (ShallowCopyPerson)super.clone();
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }
     }

接下来使用ShallowCopyPerson 类，来观察下列代码的运行结果：

 //对象浅拷贝
     private static void shallowCopyTest() {
         Address address = new Address("Henan", "zhoukou");
         ShallowCopyPerson shallowCopyPerson = new ShallowCopyPerson(
                 18,
                 "tudou",
                 address
         );
         ShallowCopyPerson personClone = (ShallowCopyPerson) shallowCopyPerson.clone();
         System.out.println("personClone info before:" + personClone.toString());
         System.out.println("shallowCopyPerson info before:" + shallowCopyPerson.toString());
         //这里改变原 shallowCopyPerson的值
         shallowCopyPerson.setName("new tudou");
         shallowCopyPerson.setAge(19);
         //改变address的地址值
         address.setCity("fj");
         address.setProvince("fz");
         shallowCopyPerson.setAddress(address);
         System.out.println("personClone info after:" + personClone.toString());
         System.out.println("shallowCopyPerson info before:" + shallowCopyPerson.toString());
     }

shallowCopyTest

结果如下：

 ersonClone info before:ShallowCopyPerson{age=18, name='tudou', address=Address{province='Henan', city='zhoukou'}}
 shallowCopyPerson info before:ShallowCopyPerson{age=18, name='tudou', address=Address{province='Henan', city='zhoukou'}}
 personClone info after:ShallowCopyPerson{age=18, name='tudou', address=Address{province='fz', city='fj'}}
 shallowCopyPerson info before:ShallowCopyPerson{age=19, name='new tudou', address=Address{province='fz', city='fj'}}

从结果可以看到：age和name字段 在原对象shallowCopyPerson的属性改变之后 personclone并未改变。但是，address中的字段province和city均有改变！这种方式属于浅拷贝，即clone()方法是浅拷贝。

如何使得address中的字段值也不改变呢？就需要用到深拷贝。

 package tudou.javabasic.clone;

 /**
  * Created by tudou on 2017-02-22.
  * 深拷贝
  */
 public class DeepCopyPerson implements Cloneable {
     private int age;
     private String name;
     private Address address;

     public DeepCopyPerson(int age, String name, Address address) {
         this.age = age;
         this.name = name;
         this.address = address;
     }
     public Object clone() {
         try {
             return (DeepCopyPerson)super.clone();
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }
     }

     public Address getAddress() {
         return address;
     }

     public void setAddress(String province, String city) {
         address = new Address(province,city);
         address.setCity(city);
         address.setProvince(province);
     }

     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 String toString() {
         return "ShallowCopyPerson{" +
                 "age=" + age +
                 ", name='" + name + '\'' +
                 ", address=" + address +
                 '}';
     }
 }

DeepCopyPerson

运行下面代码：

     //对象深拷贝
     private static void deepCopyTest() {
         Address address = new Address("Henan", "zhoukou");
         DeepCopyPerson deepCopyPerson = new DeepCopyPerson(
                 18,
                 "tudou",
                 address
         );
         DeepCopyPerson personClone = (DeepCopyPerson) deepCopyPerson.clone();
         System.out.println("personClone info before:" + personClone.toString());
         //这里改变原 shallowCopyPerson的值
         deepCopyPerson.setName("new tudou");
         deepCopyPerson.setAge(19);
         //改变address的地址值
 //        address.setCity("zhengzhou");
         deepCopyPerson.setAddress("fj","fz");
         System.out.println("personClone info after:" + personClone.toString());
     }

deepCopyTest

结果如下：

personClone info before:ShallowCopyPerson{age=18, name='tudou', address=Address{province='Henan', city='zhoukou'}}
personClone info after:ShallowCopyPerson{age=18, name='tudou', address=Address{province='Henan', city='zhoukou'}}

可以看到这里值完全没有改变。这里实现的深拷贝只是简单的来实现效果，不做效率方面的考虑。

总结

对象赋值：把一个对象的地址复制给另一个对象，二者都指向堆栈中的地址。所以一个对象中的值变了，另一个也会变。

浅拷贝：对于基本类型，克隆对象和原对象相互独立，没有影响，对于引用类型，复制的还是地址值，所以一个改变了，另一个也会改变。

深拷贝：原对象和克隆对象相互独立，不受影响。