Java实现深拷贝和浅拷贝

1.类实现Cloneable才可以进行对象拷贝

2.Cloneable只实现浅拷贝，需要实现深拷贝的必须要重写clone()方法

3.利用反序列化也可以实现深拷贝，但是反序列化耗时较长

n.浅拷贝是指拷贝对象时只拷贝对象本身和其基本变量及引用变量，不拷贝对象中引用指向的对象，深拷贝反之

4.可以浅拷贝的对象类

 package deepCopy;

 import java.io.Serializable;

 public class UserShallowClone implements Cloneable,Serializable{

     /**
      *
      */
     private static final long serialVersionUID = 222;
     private int age;
     private String name;
     private House house;

     public UserShallowClone(int age, String name, House house) {
         super();
         this.age = age;
         this.name = name;
         this.house = house;
     }

     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 House getHouse() {
         return house;
     }

     public void setHouse(House house) {
         this.house = house;
     }

     @Override
     protected Object clone() throws CloneNotSupportedException {
         // TODO Auto-generated method stub
         return super.clone();
     }

 }

5.可以深拷贝的对象类

 package deepCopy;

 public class UserDeepClone implements Cloneable{

     private int age;
     private String name;
     private House house;

     public UserDeepClone(int age, String name, House house) {
         super();
         this.age = age;
         this.name = name;
         this.house = house;
     }

     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 House getHouse() {
         return house;
     }

     public void setHouse(House house) {
         this.house = house;
     }

     @Override
     protected Object clone() throws CloneNotSupportedException {
         UserDeepClone userNew = (UserDeepClone)super.clone();
         userNew.house = (House) house.clone();
         return userNew;
     }

 }

6.House类

 package deepCopy;

 import java.io.Serializable;

 public class House implements Cloneable,Serializable{

     /**
      *
      */
     private static final long serialVersionUID = 33;
     private int zipCode;

     public House(int zipCode) {
         super();
         this.zipCode = zipCode;
     }

     public int getZipCode() {
         return zipCode;
     }

     public void setZipCode(int zipCode) {
         this.zipCode = zipCode;
     }

     @Override
     protected Object clone() throws CloneNotSupportedException {
         // TODO Auto-generated method stub
         return super.clone();
     }

 }

7.测试类

package deepCopy;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException
    {
        //deep copy
        long deepClone = System.currentTimeMillis();
        House house = new House(1010);
        UserDeepClone userDeep = new UserDeepClone(11, "CC", house);
        UserDeepClone userDeepCopy = (UserDeepClone) userDeep.clone();
        System.out.println("deep copy by cloneable speeds " +(System.currentTimeMillis()-deepClone) + "ms");
        System.out.println("Deep Copy----------");
        System.out.println("userDeep" + userDeep
                + ",userSDeepCopy=" + userDeepCopy);
        System.out.println("userDeep house=" + userDeep.getHouse()
                + ",userDeepCopy house=" + userDeepCopy.getHouse());

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

        //shallow copy
        long shallowCopy = System.currentTimeMillis();
        UserShallowClone userShallow = new UserShallowClone(12, "CC", house);
        UserShallowClone userShallowCopy = (UserShallowClone) userShallow.clone();
        System.out.println("shallowCopy spends " + (System.currentTimeMillis()-shallowCopy) + "ms");
        System.out.println("userShallow=" + userDeep
                + ",userShallowCopy=" + userDeepCopy);
        System.out.println("userShallow house=" + userShallow.getHouse()
                + ",userShallowCopy house=" + userShallowCopy.getHouse());
        //反序列化深拷贝
        System.out.println();
        long deepSer = System.currentTimeMillis();
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(userShallow);

        ObjectInputStream oi = new ObjectInputStream(new ByteArrayInputStream(bo.toByteArray()));
        UserShallowClone  userDeepSer = (UserShallowClone) oi.readObject();
        System.out.println("deep copy by ser spends " + (System.currentTimeMillis()-deepSer) + "ms");
        System.out.println("deep copy by ser--------------------");
        System.out.println("userShallow=" + userShallow
                +",userDeepSer=" + userDeepSer);
        System.out.println("userShallow house=" + userShallow.getHouse()
                +",userDeepSer house=" + userDeepSer.getHouse());
    }
}

8.测试结果