Java中的深拷贝和浅拷贝

原创 2012年04月19日 14:05:06

1.浅拷贝与深拷贝概念

(1)浅拷贝(浅克隆)

 浅拷贝又叫浅复制,将对象中的所有字段复制到新的对象(副本)中。其中,值类型字段(java中8中原始类型)的值被复制到副本中后,在副本中的修改不会影响到源对象对应的值。而引用类型的字段被复制到副本中的还是引用类型的引用,而不是引用的对象,在副本中对引用类型的字段值做修改会影响到源对象本身。

浅拷贝简单归纳就是只复制一个对象,对象内部存在指向其他对象,数组或引用则不复制。

(2)深拷贝(深克隆)

 将对象中的所有字段复制到新的对象中。不过,无论是对象的值类型字段,还是引用类型字段,都会被重新创建并赋值,对于副本的修改,不会影响到源对象本身。

深拷贝简单归纳就是对象内部引用的对象均复制。

2.Java中的clone()方法

(1)clone()方法将对象复制了一份并返回给调用者。一般而言,clone()方法满足下面规范:

①对任何的对象x,都有x.clone() != x;//克隆对象与原对象不是同一个对象

②对任何的对象x,都有x.clone().getClass()== x.getClass();//克隆对象与原对象的类型一样

③如果对象x的equals()方法定义恰当,那么x.clone().equals(x);应该成立。

(2)Java中对象的克隆

clone()方法是在Object中定义的,而且是protected的,只有实现了Cloneable接口的类才可以在其实例上调用clone()方法,否则会抛出CloneNotSupportException。

为了获取对象的一份拷贝,我们可以利用Object类的clone()方法,也可以实现Cloneable接口,覆盖基类的clone()方法,在clone()方法中,调用super.clone()。

Cloneable接口是一个标记接口,也就是没有任何内容,定义如下:
package java.lang;
pubilc interface Cloneable{
}

 例子代码如下:

class Student implements Cloneable
{
    String name;
    int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public Object clone(){
        Object o=null;
        try{
		//Object中的clone()识别出你要复制的是哪一个对象
        		o=(Student)super.clone();
        }catch(CloneNotSupportedException e){
            System.out.println(e.toString());
        }
        return o;
    }
}
 public static void main(String[] args){
      	Student s1=new Student("zhangsan",18);
      	Student s2=(Student)s1.clone();
      	s2.name="lisi";
     	s2.age=20;
System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后,不影响学生1的值。
   }

说明:

①为什么我们在派生类中覆盖Object的clone()方法时,一定要调用super.clone()呢?

在运行时刻,Object中的clone()识别出你要复制的是哪一个对象,然后为此对象分配空间,并进行对象的复制,将原始对象的内容一一复制到新对象的存储空间中。

②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明:

//Professor没有实现Cloneable接口,默认使用java.lang.Object类的clone()方法
class Professor{
    String name;
    int age;
    Professor(String name,int age){
        this.name=name;
        this.age=age;
    }
}
//Student实现了Cloneable接口
class Student implements Cloneable{
    String name;//常量对象。
    int age;
    Professor p;
    Student(String name,int age,Professor p){
        this.name=name;
        this.age=age;
        this.p=p;
    }
    public Object clone(){
        Student o=null;
        try{
            o=(Student)super.clone();
        }catch(CloneNotSupportedException e){
            System.out.println(e.toString());
        }
	//使用Object类的clone()方法
        o.p=(Professor)this.p.clone();
        return o;
    }
}
public static void main(String[] args){
      Professor p=new Professor("wangwu",50);
      Student s1=new Student("zhangsan",18,p);
      Student s2=(Student)s1.clone();
      s2.p.name="lisi";
      s2.p.age=30;
   //学生1的教授也变成了lisi,age为30
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age); 
}

那应该如何实现深层次的克隆,即修改s2的教授不会影响s1的教授?代码改进如下:

//Professor类实现了Cloneable接口,不再使用Object默认的clone()方法
class Professor implements Cloneable{
    String name;
    int age;
    Professor(String name,int age){
        this.name=name;
        this.age=age;
    }
    public Object clone(){
        Object o=null;
        try{
            o=super.clone();
        }catch(CloneNotSupportedException e){
            System.out.println(e.toString());
        }
        return o;
    }
}
class Student implements Cloneable{
    String name;
    int age;
    Professor p;
    Student(String name,int age,Professor p){
        this.name=name;
        this.age=age;
        this.p=p;
    }
    public Object clone(){
        Student o=null;
        try{
            o=(Student)super.clone();
        }catch(CloneNotSupportedException e){
            System.out.println(e.toString());
        }
	//调用Professor类的clone()方法实现深拷贝
        o.p=(Professor)this.p.clone();
        return o;
    }
}
public static void main(String[] args){
      Professor p=new Professor("wangwu",50);
      Student s1=new Student("zhangsan",18,p);
      Student s2=(Student)s1.clone();
      s2.p.name="lisi";
     s2.p.age=30;
   //学生1的教授不改变
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
}


3.利用串行化来做深复制

把对象写到流里的过程是串行化(Serilization)过程,又叫对象序列化,而把对象从流中读出来的(Deserialization)过程叫反序列化。应当指出的是,写在流里的是对象的一个拷贝,而原对象仍然存在于JVM里面,因此在Java语言里深复制一个对象,常常可以先使对象实现Serializable接口,然后把对象(实际上只是对象的一个拷贝)写到一个流里,再从流里读出来便可以重建对象。

如下为深复制源代码:

public Object deepClone(){
 	//将对象写到流里
 	ByteArrayOutoutStream bo=new ByteArrayOutputStream();
 	ObjectOutputStream oo=new ObjectOutputStream(bo);
 	oo.writeObject(this);
 	//从流里读出来
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
 	ObjectInputStream oi=new ObjectInputStream(bi);
 	return(oi.readObject());
}
这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的,否则,就需要仔细考察那些不可串行化的对象可否设成transient,从而将之排除在复制过程之外。上例代码改进如下。
class Professor implements Serializable{
    String name;
    int age;
    Professor(String name,int age){
        this.name=name;
        this.age=age;
    }
}
class Student implements Serializable{
    String name;
    int age;
    Professor p;
    Student(String name,int age,Professor p){
        this.name=name;
        this.age=age;
        this.p=p;
    }
    public Object deepClone() throws IOException,OptionalDataException,ClassNotFoundException{
 	//将对象写到流里
 	ByteArrayOutputStream bo=new ByteArrayOutputStream();
 	ObjectOutputStream oo=new ObjectOutputStream(bo);
 	oo.writeObject(this);// object of studnet
 /	/从流里读出来
 	ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
 	ObjectInputStream oi=new ObjectInputStream(bi);
 	return(oi.readObject());
} 
public static void main(String[] args){
      Professor p=new Professor("wangwu",50);
      Student s1=new Student("zhangsan",18,p);
      Student s2=(Student)s1.deepClone();
      s2.p.name="lisi";
      s2.p.age=30;
   //学生1的教授不改变
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age); 
}
}

java的深拷贝与浅拷贝

转载:http://www.2cto.com/kf/201401/273852.htmlJava中对象的创建clone顾名思义就是复制, 在Java语言中, clone方法被对象调用,所以会复制对象。...
  • lcg910978041
  • lcg910978041
  • 2016-07-22 10:46:02
  • 9161

一看就懂的,java深拷贝浅拷贝

前言 这两天,男票兴奋地通知我,我的博客终于有排名了,刚好是20000名,原来都是千里之外。我也比较兴奋,在这里谢谢每一个看到我文章的同学。O(∩_∩)O哈哈~,为什么有一种颁奖典礼的赶脚。真的啦,...
  • XIAXIA__
  • XIAXIA__
  • 2014-12-01 21:56:31
  • 7787

Java基础-深拷贝和浅拷贝的区别

最近这段时间太忙了。以至于之前一篇博文没办法写下去。 趁着今天早上有1个半小时的空闲,写一篇 深拷贝与浅拷贝   为什么要拷贝? Java克隆是为了得到一个 完全一致的对象。 相同点:对象完...
  • wangxueming
  • wangxueming
  • 2016-07-26 13:29:52
  • 1478

java List复制:浅拷贝与深拷贝

List浅拷贝众所周知,list本质上是数组,而数组的是以地址的形式进行存储。 如上图将list A浅拷贝给list B,由于进行的是浅拷贝,所以直接将A的内容复制给了B,java中相同内容的数组指向...
  • DeMonliuhui
  • DeMonliuhui
  • 2017-01-16 12:16:33
  • 20663

JAVA中浅复制与深复制

JAVA中浅复制与深复制1.浅复制与深复制概念⑴浅复制(浅克隆)被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制...
  • accp_fangjian
  • accp_fangjian
  • 2008-05-09 15:46:00
  • 11402

浅拷贝和深拷贝(谈谈java中的clone)

clone顾名思义就是复制, 在Java语言中, clone方法被对象调用,所以会复制对象。所谓的复制对象,首先要分配一个和源对象同样大小的空间,在这个空间中创建一个新的对象。那么在java语言中,有...
  • u014727260
  • u014727260
  • 2017-02-12 19:51:31
  • 4648

java中深拷贝和浅拷贝的区别

浅拷贝是复制原对象的一个副本到另一个地方,原对象和拷贝后对象的地址不同。在拷贝对象中存在值类型和引用类型,值类型是完全拷贝,在拷贝对象中有一个一样的值类型,对拷贝对象中值类型的改变不会影响原对象。但是...
  • comcug
  • comcug
  • 2015-04-08 10:23:42
  • 226

【Java深入】深拷贝与浅拷贝详解

1.拷贝的引入(1)引用拷贝创建一个指向对象的引用变量的拷贝。例1:Teacher teacher = new Teacher("Taylor",26); Teacher otherteacher =...
  • baiye_xing
  • baiye_xing
  • 2017-05-13 11:12:43
  • 778

Java之deep copy(深复制)

前段时间碰到需要将一个Java对象进行深度拷贝的情况,但是JDK并未提供关于deep copy相关的API,唯一能用的就是一个不太稳定的clone(),所以问题就来了,如何实现稳定的deep copy...
  • hzycaicai2012
  • hzycaicai2012
  • 2015-05-07 17:54:33
  • 2587

Java中clone方法以及深复制和浅复制

Java中处理基本数据类型(如:int , char , double等),都是采用按值传递的方式执行,除此之外的其他类型都是按照引用传递(传递的是一个对象的引用)的方式执行。对象在函数调用时和使用“...
  • nuisthou
  • nuisthou
  • 2016-11-13 10:13:20
  • 1314
收藏助手
不良信息举报
您举报文章:Java中的深拷贝和浅拷贝
举报原因:
原因补充:

(最多只允许输入30个字)