对象序列化
来源:互联网 发布:淘宝怎么凑单 编辑:程序博客网 时间:2024/06/14 07:41
对象序列化是讲对象持久化的一种方式,这种方式使得对象可以永久存储于本地硬盘,并可以在网络中传输对象信息(如果目的地有相应的类字节码的话)。java中,将对象持久化有两种方式,序列化与XML读写,这篇博客主要描述对象序列化。
Serializable接口与transient关键字
Serizlizable是一个标签接口,这个接口没有任何方法需要实现,只要一个类implements Serializable,那么这个类就是可序列化的,以后可以根据序列化文件恢复这个类对象。
transient是一个关键字,被transient修饰的成员变量不会被序列化,保证了成员变量的隐私性。
反序列化是通过字节序列恢复对象,不会调用类的构造方法。
public class Person implements Serializable{ private String name; private int age; public Person() { this("",0); System.out.println("I'm constructor"); } public Person(String name,int age) { System.out.println("I'm constructor too"); this.name = name; this.age = age; } @Override public String toString() { return name+" "+age; }}
import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;public class Test{ public static void main(String[] args) throws IOException, ClassNotFoundException { Person p = new Person("asd",2); System.out.println(p); //asd 2 ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat")); out.writeObject(p); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat")); Person pX = (Person)in.readObject();//不会调用构造方法 System.out.println(pX); //asd 0,age被transient修饰了 }}
Serializable的特殊实现
Serializable是一个标签接口,你只需要implements Serializable而不需要实现任何方法。但是神奇的是,如果你implements Serializable后,添加两个方法(writeObject()和readObject()),你就可以控制序列化。
- defaultWriteObject(),defaultReadObject()连个方法就是默认的序列化函数,加入你在writeObject()方法中调用defaultWriteObject()方法,就会序列化所有没有被transient修饰的成员变量。
- 如果你序列化transient关键字修饰的成员变量,transient关键字失效,被修饰的成员变量也会被序列化
- 成员变量序列化与反序列化顺序相同
- 不会调用构造函数
import java.io.Externalizable;import java.io.IOException;import java.io.ObjectInput;import java.io.ObjectInputStream;import java.io.ObjectOutput;import java.io.ObjectOutputStream;import java.io.Serializable;public class Person implements Serializable{ private String name; private transient int age; public Person() { this("",0); System.out.println("I'm constructor"); } public Person(String name,int age) { this.name = name; this.age = age; } @Override public String toString() { return name+" "+age; } private void writeObject(ObjectOutputStream out) throws IOException { out.defaultWriteObject(); //默认序列化,序列化所有没有被transient修饰的成员变量 out.writeInt(age); //显示序列化,transient失效,age任然被序列化 } private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); //默认反序列化 this.age = in.readInt(); }}
import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;public class Test{ public static void main(String[] args) throws IOException, ClassNotFoundException { Person p = new Person("asd",2); System.out.println(p); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat")); out.writeObject(p); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat")); Person pX = (Person)in.readObject(); System.out.println(pX); }}
serialVersionUID作用
相信用过eclipse的朋友们都会看过这么一个异常,”The serializable class Person does not declare a static final serialVersionUID field of type long”
,就是一个class Person没有声明long 类型的serialVersionUID成员变量。之所以要声明这么一个成员变量,是为了验证版本是否一致,当serialVersionUID相同则认为版本一致,进行序列化/反序列化操作。具体请看下面,随便安利一下这个网站。
http://swiftlet.net/archives/1268
Externalizable
实现Externalizable接口是另一种实现对象序列化的方式,他比Serializable接口更灵活,由你自己确定哪些成员变量需要序列化。他与Serializable接口最大的不同就是他会调用默认构造函数,如果序列化的类没有公共的默认构造函数的话,就会报错。
- 实现readExternal()与writeExternal()方法
- 成员变量序列化顺序必须相同,比如你的序列化顺序是name、age、high,那么你的反序列化顺序也必须是name、age、high
- 一定要有公共的默认构造函数(反序列化时会调用)
- 如果你序列化transient关键字修饰的成员变量,transient关键字失效
import java.io.Externalizable;import java.io.IOException;import java.io.ObjectInput;import java.io.ObjectInputStream;import java.io.ObjectOutput;import java.io.ObjectOutputStream;import java.io.Serializable;public class Person implements Externalizable{ private String name; private transient int age;//失效,具体得看接口的实现 public Person() { this("",0);//即使在默认构造函数中调用别的构造函数,也不会影响 System.out.println("I'm constructor"); } public Person(String name,int age) { this.name = name; this.age = age; } @Override public String toString() { return name+" "+age; } @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(name); out.writeInt(age); } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { //反序列化顺序与序列化顺序相同 name = (String)in.readObject(); age = in.readInt(); }}
import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;public class Test{ public static void main(String[] args) throws IOException, ClassNotFoundException { Person p = new Person("asd",2); System.out.println(p); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat")); out.writeObject(p); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat")); Person pX = (Person)in.readObject();//调用默认构造函数 System.out.println(pX); }}
当序列化一个具有类成员变量的对象时
当成员变量用static修饰时,这个成员变量就成为类成员变量,这个变量的拥有者就是这个类了,当你序列化一个具有类成员变量的对象时,对象的类成员变量其实就不受控制了,最终的结果其实等于反序列那一刻,类成员变量的值而不是序列化时类成员变量的值。
import java.io.Externalizable;import java.io.IOException;import java.io.ObjectInput;import java.io.ObjectInputStream;import java.io.ObjectOutput;import java.io.ObjectOutputStream;import java.io.Serializable;public class Person implements Serializable{ public static int ID = 1; //类成员变量ID private String name; private int age; public Person() { this("",0); System.out.println("I'm constructor"); } public Person(String name,int age) { this.name = name; this.age = age; } @Override public String toString() { return ID +" "+name+" "+age; }}
import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;public class Test{ public static void main(String[] args) throws IOException, ClassNotFoundException { Person p = new Person("asd",2); System.out.println(p); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat")); out.writeObject(p); //序列化对象时,ID=1 out.close(); Person.ID = 2; //修改ID值,会影响下面反序列化ID的值 ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat")); Person pX = (Person)in.readObject(); //序列化对象时,ID=2 System.out.println(pX); }}
如果你想要保存类成员变量信息,那你就要显示序列化与反序列类成员变量了。
在Person.java中添加两个方法
public void serialize(ObjectOutput out) throws IOException { out.writeInt(ID); } public void deserizlize(ObjectInput in) throws IOException { ID = in.readInt(); }
在Test.java中显示调用上述两个方法
import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;public class Test{ public static void main(String[] args) throws IOException, ClassNotFoundException { Person p = new Person("asd",2); System.out.println(p); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat")); out.writeObject(p); p.serialize(out); //显示调用序列化 out.close(); Person.ID = 2; ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat")); Person pX = (Person)in.readObject(); //显示调用反序列化 p.deserizlize(in); System.out.println(pX); }}
最后,对象序列化有一个致命的缺陷,就是我这个对象是用java序列化的,那你想要获取我这个对象,你就也得用java来反序列化从而获取我这个对象,这相比XML就有些不足了,因为XML不受平台于语言的限制。
以上(by the way ,今天剪的头真难看!!!)
Referer
-《think in java》
- Java对象序列化
- 对象序列化
- Java对象序列化
- 对象序列化笔记
- 对象的序列化
- 对象序列化
- 对象序列化
- Java对象序列化
- Java对象序列化
- java对象序列化
- Java 对象序列化
- 对象的序列化
- 序列化ArcEngine对象
- 对象序列化
- Java 对象序列化
- Java对象序列化
- 序列化对象传输
- 序列化对象
- Android--从零单排系列(1)--打电话,发短信
- Unity调用IOS时间日期控件UIDatePicker
- JVM性能调优5:Heap堆分析方法
- iOS-沙盒路径
- 1007. Maximum Subsequence Sum (25)
- 对象序列化
- java获取cpu、内存、硬盘信息
- Java 7之基础 - 强引用、弱引用、软引用、虚引用
- 算法复习:最大团问题(回溯法和分支限界法)
- Linux系统中采用Atlas+Keepalived实现MySQL读写分离、负载均衡
- C++中 #ifdef 和#endif的作用
- 汇编语言(三)内存拷贝问题 以及 汇编数据 不能以字母打头
- poj 2506 Tiling
- 逻辑斯蒂回归模型