详解java中的深拷贝和浅拷贝（clone()方法的重写、使用序列化实现真正的深拷贝）

public class CloneUtils {

   @SuppressWarnings ( "unchecked" )

   public static <T extends Serializable> T clone(T object){

     T cloneObj = null ;

     try {

       ByteArrayOutputStream out = new ByteArrayOutputStream();

       ObjectOutputStream obs = new ObjectOutputStream(out);

       obs.writeObject(object);

       obs.close();

       ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());

       ObjectInputStream ois = new ObjectInputStream(ios);

       cloneObj = (T) ois.readObject();

     } catch (Exception e){

       e.printStackTrace();

     }

     return cloneObj;

   }

}

public class TestString {

   public static void main(String[] args) {

     TestString test = new TestString();

     System.out.println( "-------浅拷贝---------" );

     test.qianCopyTest();

     System.out.println();

     System.out.println( "--------使用clone深拷贝--------" );

     test.defaultCloneTest();

     System.out.println();

     System.out.println( "--------使用序列化实现对象的拷贝--------" );

     test.streamClonrTest();

     System.out.println( "--------耗时对比--------" );

     System.out.println( "耗时1 : " + test.qianCopyCost());

     System.out.println( "耗时2 : " + test.CloneCopyCost());

     System.out.println( "耗时3 : " + test.StreamCopyCost());

   }

   /*浅拷贝*/

   private void qianCopyTest() {

     String s = "cd";

     change(s);

     System.out.println(s);

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

     String b = new String("cd");

     change(b);

     System.out.println(b);

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

     int me = 1;

     change(me);

     System.out.println(me);

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

     Person person = new Person("我", 13,new Email("我"));

     change(person);

     System.out.println(person.toString());

   }

   /*使用默认的clone方法，需要Person实现Cloneable接口*/

   private void defaultCloneTest(){

     Person person = new Person("我", 13,new Email("我"));

     Person person1 = person.clone();

     Person person2 = person.clone();

     System.out.println("person : 【"+person+"】");

     System.out.println("person1 : 【"+person1+"】");

     System.out.println("person2 : 【"+person2+"】");

     //改一个就会触动全部！！ 这就是使用默认的clone方法的弊端

     /*该clone()方法是使用Object类的clone()方法，但是该方法存在一个缺陷，它并不会将对象的所有属性全部拷贝过来，而是有选择性的拷贝，基本规则如下：

        1、 基本类型

          如果变量是基本很类型，则拷贝其值，比如int、float等。

        2、 对象

          如果变量是一个实例对象，则拷贝其地址引用，也就是说此时新对象与原来对象是公用该实例变量。

        3、 String字符串

          若变量为String字符串，则拷贝其地址引用。但是在修改时，它会从字符串池中重新生成一个新的字符串，原有紫都城对象保持不变。*/

     person.getEmail().setContent("你");

     System.out.println("之后的person : 【"+person+"】");

     System.out.println("之后的person1 : 【"+person1+"】");

     System.out.println("之后的person2 : 【"+person2+"】");

   }

   /*使用序列化实现对象的拷贝，需要对象以及对象中的其他对象都要实现Serializable接口*/

   private void streamClonrTest(){

     Person person = new Person("我", 13,new Email("我"));

     Person person1 = CloneUtils.clone(person);

     Person person2 = CloneUtils.clone(person);

     System.out.println("person : 【"+person+"】");

     System.out.println("person1 : 【"+person1+"】");

     System.out.println("person2 : 【"+person2+"】");

     person.getEmail().setContent("你");

     System.out.println("之后的person : 【"+person+"】");

     System.out.println("之后的person1 : 【"+person1+"】");

     System.out.println("之后的person2 : 【"+person2+"】");

   }

   private static void change(String x) {

     x = "ab";

   }

   private static void change(int x) {

     x = 2;

   }

   private static void change(Person x) {

     x = new Person("你", 20, new Email("你"));

   }

   private long qianCopyCost(){

     long start = System.currentTimeMillis();

     Person person = new Person("我", 13,new Email("我"));

     List<Person> list = new ArrayList<>();

     for(int i = 0;i<=10000;i++){

       list.add(new Person("你", 20, new Email("你")));

     }

     return System.currentTimeMillis()-start;

   }

   private long CloneCopyCost(){

     long start = System.currentTimeMillis();

     Person person = new Person("我", 13,new Email("我"));

     List<Person> list = new ArrayList<>();

     for(int i = 0;i<=10000;i++){

       list.add(person.clone());

     }

     return System.currentTimeMillis()-start;

   }

   private long StreamCopyCost(){

     long start = System.currentTimeMillis();

     Person person = new Person("我", 13,new Email("我"));

     List<Person> list = new ArrayList<>();

     for(int i = 0;i<=10000;i++){

       list.add(CloneUtils.clone(person));

     }

     return System.currentTimeMillis()-start;

   }

}

class Person implements Serializable, Cloneable {

   private static final long serialVersionUID = -8584225043397465132L;

   private String name;

   private int age;

   public void setEmail(Email email) {

     this.email = email;

   }

   private Email email;

   public Email getEmail() {

     return email;

   }

   public void setName(String name) {

     this.name = name;

   }

   public void setAge(int age) {

     this.age = age;

   }

   public Person(String name, int age, Email email) {

     this.name = name;

     this.age = age;

     this.email = email;

   }

   @Override

   public String toString() {

     return "name : " + name + " | age : " + age +" | content : "+email.getContent();

   }

   @Override

   protected Person clone() {

     Person person = null;

     try {

       person = (Person) super.clone();

       /*如果加上下一行 [使用clone深拷贝] 就不会改一处其他都改变了*/

       person.setEmail( new Email(person.getEmail().getContent()));

     } catch (CloneNotSupportedException e) {

       e.printStackTrace();

     }

     return person;

   }

}

class Email implements Serializable {

   private static final long serialVersionUID = 1426052929769365539L;

   private String content;

   public void setContent(String content) {

     this .content = content;

   }

   public String getContent() {

     return content;

   }

   public Email(String content) {

     this .content = content;

   }

}