Java浅拷贝、深拷贝和序列化
1.简单变量拷贝
如果你想要复制一个简单变量,很简单
1. int a = 10;
2. int b = a;
对于原始数据类型,都能够使用以上方法
2.浅拷贝
2.1 那么如何复制一个对象?
使用以上方法:
class Student{
private String name;
public Student(String name){
this.name = name;
}
public Student(){
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
public class CloneTest {
public static void main(String[] args) {
Student s1 = new Student("lgp");
Student s2 = s1;
System.out.println("学生1:" + s1.getName());
System.out.println("学生2:" + s2.getName());
}
s2.setName("pgl");
System.out.println("学生1:" +s1.getName());
System.out.println("学生2:" +s2.getName());
}
打印结果:
学生1:lgp
学生2:lgp
学生1:pgl
学生2:pgl
这是因为原变量与副本都是同一对象的引用,任一变量改变都会影响另一个变量
2.2 浅拷贝
如果希望s2是一个新的对象,它的初始状态与s1相同,但是它们之后各自会有各自的不同状态。这个情况就可以使用clone方法;
clone方法是Object类中的protected方法,所以不能在类外进行访问
要想对一个对象进行复制,就需要对clone方法覆盖。
一般步骤是(浅拷贝):
-
被拷贝的类需要实现Clonenable接口(不实现的话在调用clone方法会抛出CloneNotSupportedException异常) 该接口为标记接口(不含任何方法)
-
覆盖clone()方法,访问修饰符设为public。方法中调用super.clone()方法得到需要的拷贝对象,(native为本地方法)
实现以上方法:
public class CloneTest {
public static void main(String[] args) {
Student s1 = new Student("lgp");
Student s2 = null;
try {
s2 = s1.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
System.out.println("学生1:" + s1.getName());
System.out.println("学生2:" + s2.getName());
s2.setName("pgl");
System.out.println("学生1:" + s1.getName());
System.out.println("学生2:" + s2.getName());
}
}
class Student implements Cloneable{
private String name;
public Student(String name){
this.name = name;
}
public Student(){
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public Student clone() throws CloneNotSupportedException {
return (Student)super.clone();
}
}
打印结果:
学生1:lgp
学生2:lgp
学生1:lgp
学生2:pgl
3.深拷贝
3.1 浅拷贝的不足
Object类中的clone方法,对对象逐个域地进行拷贝。如果对象中的所有数据域都是数值或其他基本类型,拷贝这些域没有问题。但是如果对象中包含子类引用,拷贝域就会得到相同子对象的拎一个引用,那么原来的对象与克隆的对象仍然会共享一些信息。
例如:
public class CloneTest {
public static void main(String[] args) {
Address addr = new Address("fz");
Student s1 = new Student("lgp", addr);
Student s2 = null;
try {
s2 = s1.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
System.out.println("学生1:" + s1.getName() + "住址" + s1.getAddress().getAddr());
System.out.println("学生2:" + s2.getName() + "住址" + s2.getAddress().getAddr());
addr.setAddr("bj");
System.out.println("学生1:" + s1.getName() + "住址" + s1.getAddress().getAddr());
System.out.println("学生2:" + s2.getName() + "住址" + s2.getAddress().getAddr());
}
}
class Student implements Cloneable{
private String name;
private Address address;
public Student(String name, Address address){
this.name = name;
this.address = address;
}
public Student(){
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAddress(Address address) {
this.address = address;
}
public Address getAddress() {
return address;
}
@Override
public Student clone() throws CloneNotSupportedException {
return (Student)super.clone();
}
}
class Address{
private String addr;
public Address(String addr){
this.addr = addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getAddr() {
return addr;
}
}
打印结果:
学生1:lgp住址fz
学生2:lgp住址fz
学生1:lgp住址bj
学生2:lgp住址bj
为什么两个学生的地址都改变了?
原因是浅复制只是复制了addr变量的引用,并没有真正的开辟另一块空间,将值复制后再将引用返回给新对象。
3.2 深拷贝
所以,为了达到真正的复制对象,而不是纯粹引用复制。我们需要将Address类可复制化,并且修改clone方法,完整代码如下:
public class CloneTest {
public static void main(String[] args) {
Address addr = new Address("fz");
Student s1 = new Student("lgp", addr);
Student s2 = null;
try {
s2 = s1.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
System.out.println("学生1:" + s1.getName() + "住址" + s1.getAddress().getAddr());
System.out.println("学生2:" + s2.getName() + "住址" + s2.getAddress().getAddr());
addr.setAddr("bj");
System.out.println("学生1:" + s1.getName() + "住址" + s1.getAddress().getAddr());
System.out.println("学生2:" + s2.getName() + "住址" + s2.getAddress().getAddr());
}
}
class Student implements Cloneable{
private String name;
private Address address;
public Student(String name, Address address){
this.name = name;
this.address = address;
}
public Student(){
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAddress(Address address) {
this.address = address;
}
public Address getAddress() {
return address;
}
@Override
public Student clone() throws CloneNotSupportedException {
Student cloned = (Student)super.clone();
cloned.address = address.clone();
return cloned;
}
}
class Address implements Cloneable{
private String addr;
public Address(String addr){
this.addr = addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getAddr() {
return addr;
}
@Override
public Address clone() throws CloneNotSupportedException {
return (Address)super.clone();
}
}
打印结果
学生1:lgp住址fz
学生2:lgp住址fz
学生1:lgp住址bj
学生2:lgp住址fz
存在这样一个问题:类0里有类1,类1里面又有类2 .,类2里又有类3,如此嵌套引用深拷贝就会非常麻烦;
所以下面介绍一个深拷贝更简便的实现方法:使用序列化
4.序列化
4.1 定义
什么是序列化?什么是反序列化?
序列化: 把Java对象转换为字节序列的过程。
反序列化:把字节序列恢复为Java对象的过程。
4.2 作用
为什么需要序列化?
在当今的网络社会,我们需要在网络上传输各种类型的数据,包括文本、图片、音频、视频等, 而这些数据都是以二进制序列的形式在网络上传送的,那么发送方就需要将这些数据序列化为字节流后传输,而接收方接到字节流后需要反序列化为相应的数据类型。当然接收方也可以将接收到的字节流存储到磁盘中,等到以后想恢复的时候再恢复。
综上,可以得出对象的序列化和反序列化主要有两种用途:
- 把对象的字节序列永久地保存到磁盘上。(持久化对象)
- 可以将Java对象以字节序列的方式在网络中传输。(网络传输对象)可以将Java对象以字节序列的方式在网络中传输。(网络传输对象)
4.3 如何实现
如果要让某个对象支持序列化机制,则其类必须实现下面这两个接口中任一个。
- Serializable
public interface Serializable {
}
- Externalizable、
public interface Externalizable extends java.io.Serializable {
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
4.4 序列化机制算法
- 所有序列化过的,包括磁盘中的的实例对象都有一个序列化编号
- 当试图序列化一个对象时,程序会先检查该对象是否已经被序列化过,当对象在本次虚拟机中从未被序列化过,则系统将其序列化为字节序列并输出
- 如果某个对象在本次虚拟机中已经序列化过,则直接输出这个序列化编号
鉴于以上的算法可能会造成一个潜在的问题:当序列化一个可变对象时,只有第一次使用writeObject()方法输出时才会输出字节序列,而第二次调用时仅仅输出一个序列化编号,即使我们改变了这个对象的一些属性,这些改变后的属性也不会序列化到磁盘上,这点在开发中需要非常注意。
4.5 版本 serialVersionUID
Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。在进行反序列化时,JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较,如果相同就认为是一致的,可以进行反序列化,否则就会出现序列化版本不一致的异常,即是InvalidCastException。
具体的序列化过程是这样的:序列化操作的时候系统会把当前类的serialVersionUID写入到序列化文件中,当反序列化时系统会去检测文件中的serialVersionUID,判断它是否与当前类的serialVersionUID一致,如果一致就说明序列化类的版本与当前类版本是一样的,可以反序列化成功,否则失败。
serialVersionUID有两种显示的生成方式:
- 一是默认的1L,比如:private static final long serialVersionUID = 1L;
- 二是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段,比如:
private static final long serialVersionUID = xxxxL;
当实现java.io.Serializable接口的类没有显式地定义一个serialVersionUID变量时候,Java序列化机制会根据编译的Class自动生成一个serialVersionUID作序列化版本比较用,这种情况下,如果Class文件(类名,方法明等)没有发生变化(增加空格,换行,增加注释等等),就算再编译多次,serialVersionUID也不会变化的。
如果我们不希望通过编译来强制划分软件版本,即实现序列化接口的实体能够兼容先前版本,就需要显式地定义一个名为serialVersionUID,类型为long的变量,不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。
那么我们如何维护这个版本号呢?
- 只修改了类的方法,无需改变serialVersionUID;
- 只修改了类的static变量和使用transient 修饰的实例变量,无需改变serialVersionUID;
- 如果修改了实例变量的类型,例如一个变量原来是int改成了String,则反序列化会失败,需要修改serialVersionUID;如果删除了类的一些实例变量,可以兼容无需修改;如果给类增加了一些实例变量,可以兼容无需修改,只是反序列化后这些多出来的变量的值都是默认值。
4.6 继承及引用对象序列化
当要序列化的类存在父类的时候,直接或者间接父类,其父类也必须可以序列化。
当要序列化的类中引用了其他类的对象,那么这些对象的类也必须是可序列化的。
- 如果子类实现Serializable接口而父类未实现时,父类不会被序列化!
- 如果父类实现序列化,子类自动实现序列化,不需要显式实现Serializable接口。
4.7 实现Serializable接口
Address类:
class Address implements Cloneable, Serializable {
private static final long serialVersionUID = 123456789L;
private String addr;
public Address(String addr){
this.addr = addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getAddr() {
return addr;
}
@Override
public Address clone() throws CloneNotSupportedException {
return (Address)super.clone();
}
}
序列化: 那么我们如何将此类的对象序列化后保存到磁盘上呢?
- 创建一个 ObjectOutputStream 输出流oos
- 调用此输出流oos的writeObject()方法
public static void main(String[] args) {
try {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
Address addr = new Address("fz");
oos.writeObject(addr);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
这样就把addr对象写入了object.txt文件中
反序列化:我们如从文本文件中将此对象的字节序列恢复成Address对象呢?
- 创建一个ObjectInputStream 输入流ois
- 调用此输入流ois的readObject()方法。
public static void main(String[] args) {
try {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
Address addr1 = (Address) ois.readObject();
System.out.println(addr.getAddr());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
4.8 实现Externalizable接口
Externalizable将序列化和反序列化的工作完全交给了程序员,那样的好处就是自由度变大,一般情况下还是使用Serializable较为稳妥。
public class Teacher implements Externalizable{
private String name;
private Integer age;
public Teacher(String name,Integer age){
System.out.println("有参构造");
this.name = name;
this.age = age;
}
//setter、getter方法省略
//编写自己的序列化逻辑
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject("hello:"+name); //将name加上前缀
out.writeInt(age); //注掉这句后,age属性将不能被序化
}
//编写自己的反序列化逻辑
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
name = ((StringBuffer) in.readObject()).reverse().toString();
age = in.readInt();
}
@Override
public String toString() {
return "[" + name + ", " + age+ "]";
}
}
4.9 选择序列化
transient
当对某个对象进行序列化时,系统会自动将该对象的所有属性依次进行序列化,如果某个属性引用到别一个对象,则被引用的对象也会被序列化。如果被引用的对象的属性也引用了其他对象,则被引用的对象也会被序列化。 这就是递归序列化。
有时候,我们并不希望出现递归序列化,或是某个存敏感信息(如银行密码)的属性不被序列化,我们就可通过transient关键字修饰该属性来阻止被序列化。
writeObject()方法与readObject()方法
使用transient关键字阻止序列化虽然简单方便,但被它修饰的属性被完全隔离在序列化机制之外,导致了在反序列化时无法获取该属性的值,而通过在需要序列化的对象的Java类里加入writeObject()方法与readObject()方法可以控制如何序列化各属性,甚至完全不序列化某些属性(此时就transient一样)。
如果我们想要Person类里的name属性在序列化后存在文件里不让别人知道具体是什么(加密),我们就可在Person类里加如下代码:
class Person implements Serializable{
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
private void writeObject(ObjectOutputStream out) throws IOException {
// out.defaultWriteObject(); // 将当前类的非静态和非瞬态字段写入此流。
//如果不写,如果还有其他字段,则不会被序列化
out.writeObject(new StringBuffer(name).reverse());
//将name简单加密(反转),这样别人就知道是怎么回事,当然实际应用不可能这样加密。
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
//in.defaultReadObject();// 从此流读取当前类的非静态和非瞬态字段。
//如果不写,其他字段就不能被反序列化
name = ((StringBuffer)in.readObject()).reverse().toString(); //解密
age = in.readInt();
}
}
4.10 利用序列化来做深拷贝
把对象写到流里的过程是序列化过程(Serialization),而把对象从流中读出来的过程则叫做反序列化过程(Deserialization)。
应当指出的是,写在流里的是对象的一个拷贝,而原对象仍然存在于JVM里面。
public class CloneTest {
public static void main(String[] args) {
try {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Student.txt"));
Address addr1 = new Address("fz");
Student stu1 = new Student("stu1", addr1);
oos.writeObject(stu1);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Student.txt"));
Student stu2 = (Student) ois.readObject();
System.out.println("学生1:" + stu1.getName() + " ,住址:" + stu1.getAddress().getAddr());
System.out.println("学生2:" + stu2.getName() + " ,住址:" + stu2.getAddress().getAddr());
System.out.println();
stu2.getAddress().setAddr("xm");
System.out.println("学生1:" + stu1.getName() + "住址:" + stu1.getAddress().getAddr());
System.out.println("学生2:" + stu2.getName() + "住址:" + stu2.getAddress().getAddr());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class Student implements Serializable{
private String name;
private Address address;
public Student(String name, Address address){
this.name = name;
this.address = address;
}
public Student(){
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAddress(Address address) {
this.address = address;
}
public Address getAddress() {
return address;
}
}
class Address implements Serializable {
private String addr;
public Address(String addr){
this.addr = addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getAddr() {
return addr;
}
}
4.11 序列化对象注意事项
- 对象的类名、属性都会被序列化;而方法、static属性(静态属性)、transient属性(即瞬态属性)都不会被序列化(这也就是第4条注意事项的原因)
- 虽然加static也能让某个属性不被序列化,但static不是这么用的
- 要序列化的对象的引用属性也必须是可序列化的,否则该对象不可序列化,除非以transient关键字修饰该属性使其不用序列化。
- 反序列化地象时必须有序列化对象生成的class文件(很多没有被序列化的数据需要从class文件获取)
- 当通过文件、网络来读取序列化后的对象时,必须按实际的写入顺序读取。