【转载】java 中的深拷贝和浅拷贝

Posted by czjuttsw on July 29, 2017 | Viewed times

原文链接,作者:czjuttsw

假如说你想复制一个简单变量。很简单:

int apples = 5;  
int pears = apples;  

不仅仅是 int 类型,其它七种原始数据类型 (boolean,char,byte,short,float,double.long) 同样适用于该类情况。但是如果你复制的是一个对象,情况就有些复杂了。假设说我是一个 beginner,我会这样写:

class Student {  
    private int number;  
  
    public int getNumber() {  
        return number;  
    }  
  
    public void setNumber(int number) {  
        this.number = number;  
    }  
      
}  
public class Test {  
      
    public static void main(String args[]) {  
          
        Student stu1 = new Student();  
        stu1.setNumber(12345);  
        Student stu2 = stu1;  
          
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
    }  
}  

打印结果:学生1:12345,学生2:12345

这里我们自定义了一个学生类,该类只有一个 number 字段。 我们新建了一个学生实例,然后将该值赋值给 stu2 实例。(Student stu2 = stu1;) 再看看打印结果,作为一个新手,拍了拍胸腹,对象复制不过如此, 难道真的是这样吗?

我们试着改变 stu2 实例的 number 字段,再打印结果看看:

stu2.setNumber(54321);  
  
System.out.println("学生1:" + stu1.getNumber());  
System.out.println("学生2:" + stu2.getNumber());  

打印结果:学生1:54321,学生2:54321

这就怪了,为什么改变学生2的学号,学生1的学号也发生了变化呢?原因出在 (stu2 = stu1) 这一句。该语句的作用是将 stu1 的引用赋值给 stu2,这样,stu1 和 stu2 指向内存堆中同一个对象。如图: image

那么,怎样才能达到复制一个对象呢?

是否记得万类之王 Object。它有 11 个方法,有两个 protected 的方法,其中一个为 clone 方法。该方法的签名是:

protected native Object clone() throws CloneNotSupportedException;

因为每个类直接或间接的父类都是 Object,因此它们都含有 clone() 方法,但是因为该方法是 protected,所以都不能在类外进行访问。要想对一个对象进行复制,就需要对 clone 方法覆盖。

一般步骤是(浅复制):

  1. 被复制的类需要实现 Clonenable 接口(不实现的话在调用 clone 方法会抛出 CloneNotSupportedException 异常) 该接口为标记接口(不含任何方法)
  2. 覆盖 clone() 方法,访问修饰符设为 public。方法中调用 super.clone() 方法得到需要的复制对象,( native 为本地方法) 下面对上面那个方法进行改造:
    class Student implements Cloneable{  
     private int number;  
      
     public int getNumber() {  
         return number;  
     }  
      
     public void setNumber(int number) {  
         this.number = number;  
     }  
          
     @Override  
     public Object clone() {  
         Student stu = null;  
         try{  
             stu = (Student)super.clone();  
         }catch(CloneNotSupportedException e) {  
             e.printStackTrace();  
         }  
         return stu;  
     }  
    }  
    public class Test {  
          
     public static void main(String args[]) {  
              
         Student stu1 = new Student();  
         stu1.setNumber(12345);  
         Student stu2 = (Student)stu1.clone();  
              
         System.out.println("学生1:" + stu1.getNumber());  
         System.out.println("学生2:" + stu2.getNumber());  
              
         stu2.setNumber(54321);  
          
         System.out.println("学生1:" + stu1.getNumber());  
         System.out.println("学生2:" + stu2.getNumber());  
     }  
    }  
    

打印结果:学生1:12345,学生2:12345,学生1:12345,学生2:54321 如果你还不相信这两个对象不是同一个对象,那么你可以看看这一句:

System.out.println(stu1 == stu2); // false  

上面的复制被称为浅复制 (Shallow Copy),还有一种稍微复杂的深度复制 (deep copy):我们在学生类里再加一个 Address 类。

class Address  {  
    private String add;  
  
    public String getAdd() {  
        return add;  
    }  
  
    public void setAdd(String add) {  
        this.add = add;  
    }  
      
}  
  
class Student implements Cloneable{  
    private int number;  
  
    private Address addr;  
      
    public Address getAddr() {  
        return addr;  
    }  
  
    public void setAddr(Address addr) {  
        this.addr = addr;  
    }  
  
    public int getNumber() {  
        return number;  
    }  
  
    public void setNumber(int number) {  
        this.number = number;  
    }  
      
    @Override  
    public Object clone() {  
        Student stu = null;  
        try{  
            stu = (Student)super.clone();  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        return stu;  
    }  
}  
public class Test {  
      
    public static void main(String args[]) {  
          
        Address addr = new Address();  
        addr.setAdd("杭州市");  
        Student stu1 = new Student();  
        stu1.setNumber(123);  
        stu1.setAddr(addr);  
          
        Student stu2 = (Student)stu1.clone();  
          
        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
    }  
}  

打印结果:学生1:123,地址:杭州市,学生2:123,地址:杭州市 乍一看没什么问题,真的是这样吗? 我们在 main 方法中试着改变 addr 实例的地址。

addr.setAdd("西湖区");  
  
System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  

打印结果:学生1:123,地址:杭州市,学生2:123,地址:杭州市,学生1:123,地址:西湖区,学生2:123,地址:西湖区

这就奇怪了,怎么两个学生的地址都改变了? 原因是浅复制只是复制了 addr 变量的引用,并没有真正的开辟另一块空间,将值复制后再将引用返回给新对象。 所以,为了达到真正的复制对象,而不是纯粹引用复制。我们需要将 Address 类可复制化,并且修改 clone 方法,完整代码如下:

package abc;  
  
class Address implements Cloneable {  
    private String add;  
  
    public String getAdd() {  
        return add;  
    }  
  
    public void setAdd(String add) {  
        this.add = add;  
    }  
      
    @Override  
    public Object clone() {  
        Address addr = null;  
        try{  
            addr = (Address)super.clone();  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        return addr;  
    }  
}  
  
class Student implements Cloneable{  
    private int number;  
  
    private Address addr;  
      
    public Address getAddr() {  
        return addr;  
    }  
  
    public void setAddr(Address addr) {  
        this.addr = addr;  
    }  
  
    public int getNumber() {  
        return number;  
    }  
  
    public void setNumber(int number) {  
        this.number = number;  
    }  
      
    @Override  
    public Object clone() {  
        Student stu = null;  
        try{  
            stu = (Student)super.clone();   //浅复制  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        stu.addr = (Address)addr.clone();   //深度复制  
        return stu;  
    }  
}  
public class Test {  
      
    public static void main(String args[]) {  
          
        Address addr = new Address();  
        addr.setAdd("杭州市");  
        Student stu1 = new Student();  
        stu1.setNumber(123);  
        stu1.setAddr(addr);  
          
        Student stu2 = (Student)stu1.clone();  
          
        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
          
        addr.setAdd("西湖区");  
          
        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
    }  
} 

打印结果:学生1:123,地址:杭州市,学生2:123,地址:杭州市,学生1:123,地址:西湖区,学生2:123,地址:杭州市

这样结果就符合我们的想法了。 最后我们可以看看 API 里其中一个实现了 clone 方法的类:Java.util.Date:

/** 
 * Return a copy of this object. 
 */  
public Object clone() {  
    Date d = null;  
    try {  
        d = (Date)super.clone();  
        if (cdate != null) {  
            d.cdate = (BaseCalendar.Date) cdate.clone();  
        }  
    } catch (CloneNotSupportedException e) {} // Won't happen  
    return d;  
}  

该类其实也属于深度复制。


0

Comment