Java解惑之深拷贝or浅拷贝

在说这个问题之前，先看一段代码

public class Person {
  public int num;
  public String name;
}

public class Test4 {
  public static void main(String[] args) {
    Person p1 = new Person();
    p1.num = 001;
    p1.name = "张三";
    Person p2 = p1;         //关注点1
    p2.name="李四";
    System.out.println(p1 == p2);
    System.out.println(p1.name);
  }
}

输出结果

true
李四

结果分析
关注点1这句代码，是将p1对象的引用(地址)拷贝给了p2，因此p1和p2指向同一个地址，p2对这个地址对应的区域做了修改，p1访问这个地址时当然拿到的是修改后的内容。

调用clone方法
上代码之前，先说下调用该代码的必备条件
实现Cloneable接口，否则会抛CloneNotSupportedException异常
重写Object类的clone方法，否则调用不到该方法
这里有几个疑问
Object类的clone方法明明是protected的，为什么子类调不到？
网上说的要将clone方法声明为public？

修改代码如下

public class Book {
  public String name;
}

public class Person implements Cloneable{
    public int num;
    public String name;
    public Book book;

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

public class Test4 {

  public static void main(String[] args) throws CloneNotSupportedException {

    //p1的属性
    Person p1 = new Person();
    Book book=new Book();
    book.name="算法导论";
    p1.num = 001;
    p1.name = "张三";
    p1.book=book;
    
    //p2的属性
    Person p2 = (Person) p1.clone();
    p2.name="李四";
    p2.book.name="操作系统";
    System.out.println(p1 == p2);
    System.out.println(p1.name);
    System.out.println(p1.book==p2.book);
    System.out.println(p1.book.name);

  }
}

输出结果

false
张三
true
操作系统

结果分析
p2是p1的一个克隆，故p1和p2此时指向不同的地址
在克隆的时候，String类型和基本类型一样都会被克隆
因为Book是自定义的对象，故无法实现克隆(深拷贝)，即p1和p2中的book对象指向的是同一个地址。

不过这里我还有个疑问
String类也是对象类型的，它没有实现Clonable接口，也没有重写clone方法，是如何实现克隆的了？

为了实现彻底的克隆，我们来修改下Book和Person的代码

public class Person implements Cloneable{
    public int num;
    public String name;
    public Book book;

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

public class Book implements Cloneable{
    public String name;
@Override
protected Object clone() throws CloneNotSupportedException {
    // TODO Auto-generated method stub
    return super.clone();
    }
}

输出结果

false
张三
false
算法导论

结果分析
在Person类的clone方法中，增加了book对象的克隆，因此p1和p2的book对象不再指向同一个地址了。

结论
Object类的clone方法只会对基本类型(对应的包装类)和String类型进行深拷贝，对于普通对象只是复制一下地址。
包装类虽然没有测试，但发现包装类是final型的，不可能继承重写clone方法，因此猜测它和String类一样是深拷贝。
想要完成彻底的深拷贝，需要对本类中的其他普通类依次调用它们的clone方法。

看了上面的叙述，不知道你是否会想，那如果我的A类包含B类，B类又包含C类.......，这样就需要对每一个类都做相应的处理，这样岂不是很费劲？别着急，下面我来介绍一下Serializable

Serializable深拷贝

public class Book1 implements Serializable{
    private static final long serialVersionUID = 1L;
    public String name;
}

public class Student implements Serializable{
    private static final long serialVersionUID = 1L;

    public int num;
    public String name;
    public Book1 book;
}

public static Object deepCopy(Object object){
    ByteArrayOutputStream bo=null;
    ObjectOutputStream oo=null;
    ByteArrayInputStream bi=null;
    ObjectInputStream oi=null;
    Object obj=null;
    try {
        //将对象写入流
        bo=new ByteArrayOutputStream();
        oo=new ObjectOutputStream(bo);
        oo.writeObject(object);
        
        //从流中读取对象
        bi=new ByteArrayInputStream(bo.toByteArray());
        oi=new ObjectInputStream(bi);
        obj=oi.readObject();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        try {
            if(oi!=null)
            oi.close();
            if(bi!=null)
                bi.close();
            if(oo!=null)
                oo.close();
            if(bo!=null)
                bo.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }   
    }
    return obj;
}

public class Test5 {

   public static void main(String[] args) {

    // s1的属性
    Student s1 = new Student();
    Book1 book = new Book1();
    book.name = "算法导论";
    s1.num = 001;
    s1.name = "张三";
    s1.book = book;

    // s2的属性
    Student s2 =(Student) Utils.deepCopy(s1);
    s2.name = "李四";
    s2.book.name = "操作系统";
    System.out.println(s1 == s2);
    System.out.println(s1.name);
    System.out.println(s1.book == s2.book);
    System.out.println(s1.book.name);
  }
}

输出结果

false
张三
false
算法导论

结果分析
此结果与上面对person和book分别调用clone方法一致，说明serializable能够对对象做深拷贝，无论该对象里是否有其他普通对象。

回到最初的问题
浅拷贝，对于引用类型，只是对地址做了拷贝，即copy前后的对象指向的是同一块内存空间。
深拷贝，对于引用类型，会在内存空间新开辟一块空间，并将被拷贝的对象的相关属性一一复制在新的内存空间内，即copy前后的对象指向的是不同的内存空间。