Java 深拷贝和浅拷贝 利用序列化实现深拷贝
Java 深拷贝和浅拷贝
转自:http://www.cnblogs.com/mengdd/archive/2013/02/20/2917971.html
深拷贝(deep clone)与浅拷贝(shallow clone)
浅拷贝(浅复制、浅克隆):被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。
换言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象。
深拷贝(深复制、深克隆):被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。
那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。
换言之,深拷贝把要复制的对象所引用的对象都复制了一遍。
Java中对象的克隆
1.为了获取对象的一份拷贝,我们可以利用Object类的clone()方法。
2.在派生类中覆盖基类的clone()方法,并声明为public。
(Object类中的clone()方法是protected的)。
在子类重写的时候,可以扩大访问修饰符的范围。
3.在派生类的clone()方法中,调用super.clone()。
因为在运行时刻,Object类中的clone()识别出你要复制的是哪一个对象,然后为此对象分配空间,并进行对象的复制,将原始对象的内容一一复制到新对象的存储空间中。
4.在派生类中实现Cloneable接口。
这个接口中没有什么方法,只是说明作用。
注意:继承自java.lang.Object类的clone()方法是浅复制。
Java的clone()方法
clone()方法定义在Object类中。
clone()方法将对象复制了一份并返回给调用者。拷贝具体的含义将取决于对象所在的类。
一般而言,clone()方法满足:
1. 克隆对象与原对象不是同一个对象。即对任何的对象x:
x.clone() != x
2.克隆对象与原对象的类型一样。即对任何的对象x:
x.clone().getClass() == x.getClass()
3.如果对象x的equals()方法定义恰当,那么下式应该成立:
x.clone().equals(x)
因为一个定义良好的equals()方法就应该是用来比较内容是否相等的。
练习程序
程序1:CloneTest1进行拷贝:
public class CloneTest1
{ public static void main(String[] args) throws CloneNotSupportedException
{
Student student1 = new Student();
student1.setName("ZhangSan");
student1.setAge(20); Student student2 = new Student();
student2 = (Student) student1.clone(); System.out.println("拷贝得到的信息");
System.out.println(student2.getName());
System.out.println(student2.getAge());
System.out.println("-------------"); // 修改第二个对象的信息
student2.setName("LiSi");
student2.setAge(25); System.out.println("修改第二个对象的属性为lisi,25后:");
System.out.println("第一个对象:");
System.out.println(student1.getName());
System.out.println(student1.getAge());
System.out.println("第二个对象:");
System.out.println(student2.getName());
System.out.println(student2.getAge());
System.out.println("-------------"); // 说明两个引用student1和student2指向的是不同的对象 }
} class Student implements Cloneable
{
private String name;
private int age; public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} @Override
public Object clone() throws CloneNotSupportedException
{
// 注意此处要把protected改为public Object object = super.clone(); return object;
}
}
程序的输出是:
拷贝得到的信息
ZhangSan
20
-------------
修改第二个对象的属性为lisi,25后:
第一个对象:
ZhangSan
20
第二个对象:
LiSi
25
-------------
CloneTest1说明拷贝生成的是两个对象。
程序2:CloneTest2:在Student类中加入Teacher类的引用,进行拷贝:
public class CloneTest2
{
public static void main(String[] args) throws CloneNotSupportedException
{
Teacher teacher = new Teacher();
teacher.setName("Teacher Zhang");
teacher.setAge(40); Student2 student1 = new Student2();
student1.setName("ZhangSan");
student1.setAge(20);
student1.setTeacher(teacher); Student2 student2 = (Student2) student1.clone();
System.out.println("拷贝得到的信息");
System.out.println(student2.getName());
System.out.println(student2.getAge());
System.out.println(student2.getTeacher().getName());
System.out.println(student2.getTeacher().getAge());
System.out.println("-------------"); // 修改老师的信息
teacher.setName("Teacher Zhang has changed");
System.out.println(student1.getTeacher().getName());
System.out.println(student2.getTeacher().getName()); // 两个引用student1和student2指向不同的两个对象
// 但是两个引用student1和student2中的两个teacher引用指向的是同一个对象
// 所以说明是浅拷贝
} } class Teacher implements Cloneable
{
private String name;
private int age; public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} } class Student2 implements Cloneable
{
private String name;
private int age;
private Teacher teacher; public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} public Teacher getTeacher()
{
return teacher;
} public void setTeacher(Teacher teacher)
{
this.teacher = teacher;
} @Override
public Object clone() throws CloneNotSupportedException
{
Object object = super.clone();
return object;
} }
程序输出:
拷贝得到的信息
ZhangSan
20
Teacher Zhang
40
-------------
Teacher Zhang has changed
Teacher Zhang has changed
CloneTest2说明Object类的clone()方法进行的是浅拷贝。
程序3:把CloneTest2改为深复制:
首先在Teacher类中加入clone()方法(必须的,因为需要借此改为public,不然无法调用),然后修改Student2类中的clone()方法,使得teacher引用也复制一份对象,然后用set方法设置回来。
public class CloneTest2
{
public static void main(String[] args) throws Exception
{
Teacher teacher = new Teacher();
teacher.setName("Teacher Zhang");
teacher.setAge(40); Student2 student1 = new Student2();
student1.setName("ZhangSan");
student1.setAge(20);
student1.setTeacher(teacher); Student2 student2 = (Student2) student1.clone();
System.out.println("拷贝得到的信息");
System.out.println(student2.getName());
System.out.println(student2.getAge());
System.out.println(student2.getTeacher().getName());
System.out.println(student2.getTeacher().getAge());
System.out.println("-------------"); // 修改老师的信息
teacher.setName("Teacher Zhang has changed");
System.out.println(student1.getTeacher().getName());
System.out.println(student2.getTeacher().getName()); // 两个引用student1和student2指向不同的两个对象
// 但是两个引用student1和student2中的两个teacher引用指向的是同一个对象
// 所以说明是浅拷贝 // 改为深复制之后,对teacher对象的修改只能影响第一个对象
}
} class Teacher implements Cloneable
{
private String name;
private int age; public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} @Override
public Object clone() throws CloneNotSupportedException
{
return super.clone();
} } class Student2 implements Cloneable
{
private String name;
private int age;
private Teacher teacher; public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} public Teacher getTeacher()
{
return teacher;
} public void setTeacher(Teacher teacher)
{
this.teacher = teacher;
} @Override
public Object clone() throws CloneNotSupportedException
{
// 浅复制时:
// Object object = super.clone();
// return object; // 改为深复制:
Student2 student = (Student2) super.clone();
// 本来是浅复制,现在将Teacher对象复制一份并重新set进来
student.setTeacher((Teacher) student.getTeacher().clone());
return student;
} }
程序输出:
拷贝得到的信息
ZhangSan
20
Teacher Zhang
40
-------------
Teacher Zhang has changed
Teacher Zhang
利用序列化实现深复制
上面例子中的方法实现深复制比较麻烦。
下面介绍一种全新的方法:利用序列化来做深复制。
把对象写到流里的过程是序列化过程(Serialization),而把对象从流中读出来的过程则叫做反序列化过程(Deserialization)。
应当指出的是,写在流里的是对象的一个拷贝,而原对象仍然存在于JVM里面。
在Java语言里深复制一个对象,常常可以先使对象实现Serializable接口,然后把对象(实际上只是对象的一个拷贝)写到一个流里,再从流里读出来,便可以重建对象。
这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的,否则,就需要仔细考察那些不可串行化的对象可否设成transient,从而将其排除在复制过程之外。
注意Cloneable与Serializable接口都是marker Interface,也就是说它们只是标识接口,没有定义任何方法。
程序4:利用序列化实现深拷贝例子:CloneTest3
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable; public class CloneTest3
{
public static void main(String[] args) throws Exception
{
Teacher3 t = new Teacher3();
t.setName("Teacher Wang");
t.setAge(50); Student3 s1 = new Student3();
s1.setAge(20);
s1.setName("ZhangSan");
s1.setTeacher(t); Student3 s2 = (Student3) s1.deepClone(); System.out.println("拷贝得到的信息:");
System.out.println(s2.getName());
System.out.println(s2.getAge());
System.out.println(s2.getTeacher().getName());
System.out.println(s2.getTeacher().getAge());
System.out.println("---------------------------"); // 将复制后的对象的老师信息修改一下:
s2.getTeacher().setName("New Teacher Wang");
s2.getTeacher().setAge(28); System.out.println("修改了拷贝对象的教师后:");
System.out.println("拷贝对象的教师:");
System.out.println(s2.getTeacher().getName());
System.out.println(s2.getTeacher().getAge());
System.out.println("原来对象的教师:");
System.out.println(s1.getTeacher().getName());
System.out.println(s1.getTeacher().getAge()); // 由此证明序列化的方式实现了对象的深拷贝 } } class Teacher3 implements Serializable
{
private String name;
private int age; public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} } class Student3 implements Serializable
{
private String name;
private int age;
private Teacher3 teacher; public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} public Teacher3 getTeacher()
{
return teacher;
} public void setTeacher(Teacher3 teacher)
{
this.teacher = teacher;
} public Object deepClone() throws Exception
{
// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); // 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis); return ois.readObject();
} }
程序输出:
拷贝得到的信息:
ZhangSan
20
Teacher Wang
50
---------------------------
修改了拷贝对象的教师后:
拷贝对象的教师:
New Teacher Wang
28
原来对象的教师:
Teacher Wang
50
serialVersionUID问题
当一个类实现了Serializable接口时,表明该类可被序列化,这个时候Eclipse会给出一个警告,要求你为该类定义一个字段,该字段名字为serialVersionUID,类型为long,提示信息如下:
The serializable class Teacher3 does not declare a static final serialVersionUID field of type long。
在Eclipse中有两种生成方式:
一个是默认的1L;
private static final long serialVersionUID = 1L;
一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段,比如:
private static final long serialVersionUID = -932183802511122207L;
如果你没有考虑到兼容性的问题,就把它关掉,不过有这个功能是好的,只要任何类别实现了Serializable接口,如果没有加入serialVersionUID,Eclipse都会给你提示,这个serialVersionUID为了让该类别Serializable向后兼容。
如果你的对象序列化后存到硬盘上面后,你却更改了类的field(增加或减少或改名),当你反序列化时,就会出现异常,这样就会造成不兼容性的问题。
但当serialVersionUID相同时,它就会将不一样的field以type的缺省值Deserialize,这个可以避开不兼容性的问题。
Java 深拷贝和浅拷贝 利用序列化实现深拷贝的更多相关文章
- C++中的深拷贝和浅拷贝 QT中的深拷贝,浅拷贝和隐式共享
下面是C++中定义的深,浅拷贝 当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候,拷贝构造函数就会被自动调用.也就是说,当类的对象需要拷贝时,拷贝构造函数将会被调用.以下情况都会 ...
- java克隆之深拷贝与浅拷贝
版权声明:本文出自汪磊的博客,转载请务必注明出处. Java深拷贝与浅拷贝实际项目中用的不多,但是对于理解Java中值传递,引用传递十分重要,同时个人认为对于理解内存模型也有帮助,况且面试中也是经常问 ...
- Java 轻松理解深拷贝与浅拷贝
目录 前言 直接赋值 拷贝 浅拷贝 举例 原理 深拷贝 实现: Serializable 实现深拷贝 总结 前言 本文代码中有用到一些注解,主要是Lombok与junit用于简化代码. 主要是看到一堆 ...
- Java基础(十三)--深拷贝和浅拷贝
在上篇文章:Java基础(十二)--clone()方法,我们简单介绍了clone()的使用 clone()对于基本数据类型的拷贝是完全没问题的,但是如果是引用数据类型呢? @Data @NoArgsC ...
- JAVA中对象的克隆及深拷贝和浅拷贝
使用场景: 在日常的编程过程 中,经常会遇到,有一个对象OA,在某一时间点OA中已经包含了一些有效值 ,此时可能会需一个和OA完全相对的新对象OB,并且要在后面的操作中对OB的任何改动都不会影响到OA ...
- 也来玩玩 javascript对象深拷贝,浅拷贝
经常看到讨论c#深拷贝,浅拷贝的博客,最近js写的比较多, 所以也来玩玩js的对象拷贝. 下面是维基百科对深浅拷贝的解释: 浅拷贝 One method of copying an object is ...
- javascript对象深拷贝,浅拷贝 ,支持数组
javascript对象深拷贝,浅拷贝 ,支持数组 经常看到讨论c#深拷贝,浅拷贝的博客,最近js写的比较多, 所以也来玩玩js的对象拷贝. 下面是维基百科对深浅拷贝的解释: 浅拷贝 One meth ...
- Java 深拷贝浅拷贝 与 序列化
一.浅拷贝.深拷贝 浅拷贝会对对象中的成员变量进行拷贝:如果是基本类型,拷贝的就是基本类型的值:如果属性是内存地址(引用类型),拷贝的就是内存地址 : 深拷贝,除了基本类型外,引用类型所引用的对象也会 ...
- java中的浅拷贝与深拷贝
浅拷贝: package test; class Student implements Cloneable { private int number; public int getNumber() { ...
随机推荐
- 洛谷 1063 dp 区间dp
洛谷 1063 dp 区间dp 感觉做完这道提高组T1的题之后,受到了深深的碾压,,最近各种不在状态.. 初看这道题,不难发现它具有区间可并性,即(i, j)的最大值可以由(i, k) 与 (k+1, ...
- windows部署iBase4J
所需环境:jdk 1.8.eclipse(myeclipse不可以).nginx.activeMQ .zookeeper.redis 第一步 下载jdk1.8 按步骤安装至指定位置即可 第二步 安装e ...
- WinServer-IIS-Dynamic IP Restrictions
动态IP限制 来自为知笔记(Wiz)
- HTML页面直接显示json 结构
<html> <head> <meta http-equiv="Content-Type" content="text/html; char ...
- Android学习之GridView图片布局适配经验
開始解说这篇博客之前,我想问一下,当布局相似GridView这样的多列布局时,我们该怎么布局,才干更好的去适配呢? 扣张图来展示一下 比如这样的需求,三张图片均分屏幕 实现方法: 1.切图固定,比如是 ...
- 数据共享之相互排斥量mutex
相互排斥量介绍 相互排斥量能够保护某些代码仅仅能有一个线程运行这些代码.假设有个线程使用相互排斥量运行某些代码,其它线程訪问是会被堵塞.直到这个线程运行完这些代码,其它线程才干够运行. 一个线程在訪问 ...
- 怎么用命令行运行jar文件
假设你配置好了jre环境,你如今有一个打包好的jar文件,你能够这样子開始运行 java -classpath example.jar mainClass -classpath告诉虚拟机在哪里找类的字 ...
- 号外:Spark 1.3.0公布了,快来一起飞!
Spark 1.3.0 Release Note Spark 1.3.0在上周五正式公布.真是千呼万唤始出来.本次公布最大的惊喜就是DataFrame.另外一个值得关注的是Spark SQL从Alph ...
- JavaScript中Math常用方法
title: JavaScript中Math常用方法 toc: false date: 2018-10-13 12:19:31 Math.E --2.718281828459045,算数常量e Mat ...
- 新型查询系统impala
这羊头很酷... Apache Impala是Apache Hadoop的开源本地分析数据库.Impala由Cloudera,MapR,Oracle和Amazon提供. 在Hadoop上进行BI风格的 ...