序列化
Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里,并且可以从其它地方把该Byte 流里的数据读出来,重新构造一个相同的对象。
当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为Java对象。
把Java对象转换为字节序列的过程称为对象的序列化。
把字节序列恢复为Java对象的过程称为对象的反序列化。
1、序列化的用途
利用对象的序列化可以保存应用程序的当前工作状态,下次再启动的时候将自动地恢复到上次执行的状态。
对象的序列化主要有两种用途:
(a) 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中;
(b) 在网络上传送对象的字节序列。
2、序列化的实现
(1)JDK类库中的序列化API
java.io.ObjectOutputStream代表对象输出流,它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化,把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream代表对象输入流,它的readObject()方法从一个源输入流中读取字节序列,再把它们反序列化为一个对象,并将其返回。
只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口,实现Externalizable接口的类完全由自身来控制序列化的行为,而仅实现Serializable接口的类可以采用默认的序列化方式 。
(2)对象序列化与反序列化的过程
将需要被序列化的类实现Serializable接口,该接口没有需要实现的方法,implements Serializable只是为了标注该对象是可被序列化的,然后使用一个输出流(如:FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象,接着,使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态),要恢复的话则用输入流。
对象序列化包括如下步骤:
(a)创建一个对象输出流,它可以包装一个其他类型的目标输出流,如文件输出流;
(b)通过对象输出流的writeObject()方法写对象。
对象反序列化的步骤如下:
(a)创建一个对象输入流,它可以包装一个其他类型的源输入流,如文件输入流;
(b)通过对象输入流的readObject()方法读取对象。
下面让我们来看一个对应的例子,类的内容如下:
import java.io.*; import java.util.Date; public class ObjectSaver { public static void main(String[] args) throws Exception { ObjectOutputStream out = new ObjectOutputStream (new FileOutputStream("D:""objectFile.obj")); //序列化对象 Customer customer = new Customer("阿蜜果", 24); out.writeObject("你好!"); out.writeObject(new Date()); out.writeObject(customer); out.writeInt(123); //写入基本类型数据 out.close(); //反序列化对象 ObjectInputStream in = new ObjectInputStream (new FileInputStream("D:""objectFile.obj")); System.out.println("obj1=" + (String) in.readObject()); System.out.println("obj2=" + (Date) in.readObject()); Customer obj3 = (Customer) in.readObject(); System.out.println("obj3=" + obj3); int obj4 = in.readInt(); System.out.println("obj4=" + obj4); in.close(); } } class Customer implements Serializable { private String name; private int age; public Customer(String name, int age) { this.name = name; this.age = age; } public String toString() { return "name=" + name + ", age=" + age; } } import java.io.*; import java.util.Date; public class ObjectSaver { public static void main(String[] args) throws Exception { ObjectOutputStream out = new ObjectOutputStream (new FileOutputStream("D:""objectFile.obj")); //序列化对象 Customer customer = new Customer("阿蜜果", 24); out.writeObject("你好!"); out.writeObject(new Date()); out.writeObject(customer); out.writeInt(123); //写入基本类型数据 out.close(); //反序列化对象 ObjectInputStream in = new ObjectInputStream (new FileInputStream("D:""objectFile.obj")); System.out.println("obj1=" + (String) in.readObject()); System.out.println("obj2=" + (Date) in.readObject()); Customer obj3 = (Customer) in.readObject(); System.out.println("obj3=" + obj3); int obj4 = in.readInt(); System.out.println("obj4=" + obj4); in.close(); } } class Customer implements Serializable { private String name; private int age; public Customer(String name, int age) { this.name = name; this.age = age; } public String toString() { return "name=" + name + ", age=" + age; } } <pre name="code" class="java"> public class Customer implements Serializable { /** * @author 奮鬥中德菜鳥 * 版权所有,并保留所有权利。 */ private static final long serialVersionUID = 1L; private String name; private int age; public Customer(String name, int age) { this.name = name; this.age = age; } public String toString() { return "name=" + name + ", age=" + age; } } public class ObjectSaver { public static void main(String[] args) throws Exception { ObjectOutputStream out = new ObjectOutputStream (new FileOutputStream("D:objectFile.obj")); //序列化对象 Customer customer = new Customer("阿蜜果", 24); out.writeObject("你好!"); out.writeObject(new Date()); out.writeObject(customer); out.writeInt(123); //写入基本类型数据 out.close(); //反序列化对象 ObjectInputStream in = new ObjectInputStream (new FileInputStream("D:objectFile.obj")); System.out.println("obj1=" + (String) in.readObject()); System.out.println("obj2=" + (Date) in.readObject()); Customer obj3 = (Customer) in.readObject(); System.out.println("obj3=" + obj3); int obj4 = in.readInt(); System.out.println("obj4=" + obj4); in.close(); } }
3、serialVersionUID作用:
序列化时为了保持版本的兼容性,即在版本升级时反序列化仍保持对象的唯一性。
有两种生成方式:
一个是默认的1L,比如:
Java代码
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段,比如:
Java代码
private static final long serialVersionUID = xxxxL; private static final long serialVersionUID = xxxxL;
二、克隆
有时想得到对象的一个复制品,该复制品的实体是原对象实体的克隆。复制品实体的变化不会引起原对象实体发生变化,这样的复制品称为原对象实体的克隆对象或简称克隆。
1、浅复制(浅克隆)
概念:被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。
方法:类implements Cloneable,然后重写clone()方法,在clone()方法中调用super.clone()即可,没有其他操作了
2、深复制(深克隆)
概念:被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换言之,深复制把要复制的对象所引用的对象都复制了一遍
方法:
(1)类implements Cloneable,然后重写clone()方法,在clone()方法中调用super.clone(),然后还要对引用型变量所指的对象进行克隆。
(2)序列化:将该对象写出到对象输出流,那么用对象输入流读回的对象就是原对象的一个深度克隆
深度克隆类:import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class DepthClone { public final static Object objectCopy(Object oldObj) { Object newObj = null; try { ByteArrayOutputStream bo = new ByteArrayOutputStream(); ObjectOutputStream oo = new ObjectOutputStream(bo); oo.writeObject(oldObj);//源对象 ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray()); ObjectInputStream oi= new ObjectInputStream(bi); newObj = oi.readObject();//目标对象 } catch (IOException e) { e.printStackTrace(); }catch (ClassNotFoundException e) { e.printStackTrace(); } return newObj; } }
import java.io.Serializable; public class SimpleClone implements Cloneable ,Serializable { private static final long serialVersionUID = -7552721152118950502L; public String s = null; public Object o = null; public CloneObject cloneObject = null; public SimpleClone(CloneObject cloneObject) { this.cloneObject = cloneObject; } public Object clone() { SimpleClone newSimpleClone = null; try { /* 浅克隆 */ newSimpleClone = (SimpleClone)super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return newSimpleClone; } }