对象的序列化和反序列化
3.对象的序列化,反序列化
1)对象序列化,就是将Object转换成byte序列,反之叫对象的反序列化
2)序列化流(ObjectOutputStream),是过滤流----writeObject
反序列化流(ObjectInputStream)---readObject
3)序列化接口(Serializable)
对象必须实现序列化接口 ,才能进行序列化,否则将出现异常
这个接口,没有任何方法,只是一个标准
4) transient关键字---该元素不会进行jvm默认的序列化
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException
分析ArrayList源码中序列化和反序列化的问题
将数组里面的有效元素进行序列化(比如数组未填满,只需要将已有的元素进行序列化)
1 import java.io.Serializable;
2
3 public class Student implements Serializable{
4 private String stuno;
5 private String stuname;
6 //该元素不会进行jvm默认的序列化,也可以自己完成这个元素的序列化
7 private transient int stuage;
8
9 public Student(String stuno, String stuname, int stuage) {
10 super();
11 this.stuno = stuno;
12 this.stuname = stuname;
13 this.stuage = stuage;
14 }
15
16 public String getStuno() {
17 return stuno;
18 }
19 public void setStuno(String stuno) {
20 this.stuno = stuno;
21 }
22 public String getStuname() {
23 return stuname;
24 }
25 public void setStuname(String stuname) {
26 this.stuname = stuname;
27 }
28 public int getStuage() {
29 return stuage;
30 }
31 public void setStuage(int stuage) {
32 this.stuage = stuage;
33 }
34 @Override
35 public String toString() {
36 return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage="
37 + stuage + "]";
38 }
39 private void writeObject(java.io.ObjectOutputStream s)
40 throws java.io.IOException{
41 s.defaultWriteObject();//把jvm能默认序列化的元素进行序列化操作
42 s.writeInt(stuage);//自己完成stuage的序列化
43 }
44 private void readObject(java.io.ObjectInputStream s)
45 throws java.io.IOException, ClassNotFoundException{
46 s.defaultReadObject();//把jvm能默认反序列化的元素进行反序列化操作
47 this.stuage = s.readInt();//自己完成stuage的反序列化操作
48 }
49 }
测试
1 import java.io.FileInputStream;
2 import java.io.ObjectInputStream;
3
4 public class ObjectSeriaDemo1 {
5 public static void main(String[] args) throws Exception{
6 String file = "demo/obj.dat";
7 //1.对象的序列化
8 /*ObjectOutputStream oos = new ObjectOutputStream(
9 new FileOutputStream(file));
10 Student stu = new Student("10001", "张三", 20);
11 oos.writeObject(stu);
12 oos.flush();
13 oos.close();*/
14 ObjectInputStream ois = new ObjectInputStream(
15 new FileInputStream(file));
16 Student stu = (Student)ois.readObject();
17 System.out.println(stu);
18 ois.close();
19
20 }
21
22
23 }
5)序列化中 子类和父类构造函数的调用问题
1 import java.io.FileInputStream;
2 import java.io.ObjectInputStream;
3 import java.io.Serializable;
4
5 public class ObjectSeriaDemo2 {
6 public static void main(String[] args) throws Exception{
7 /*ObjectOutputStream oos = new ObjectOutputStream(
8 new FileOutputStream("demo/obj1.dat"));
9 Foo2 foo2 = new Foo2();
10 oos.writeObject(foo2);
11 oos.flush();
12 oos.close();*/
13
14 //反序列化是否递归调用父类的构造函数
15 /*ObjectInputStream ois = new ObjectInputStream(
16 new FileInputStream("demo/obj1.dat"));
17 Foo2 foo2 = (Foo2)ois.readObject();
18 System.out.println(foo2);
19 ois.close();*/
20
21
22 /*ObjectOutputStream oos = new ObjectOutputStream(
23 new FileOutputStream("demo/obj1.dat"));
24 Bar2 bar2 = new Bar2();
25 oos.writeObject(bar2);
26 oos.flush();
27 oos.close();*/
28
29 ObjectInputStream ois = new ObjectInputStream(
30 new FileInputStream("demo/obj1.dat"));
31 Bar2 bar2 = (Bar2)ois.readObject();
32 System.out.println(bar2);
33 ois.close();
34
35
36 /*
37 * 对子类对象进行反序列化操作时,
38 * 如果其父类没有实现序列化接口
39 * 那么其父类的构造函数会被调用
40 */
41 }
42 }
43 /*
44 * 一个类实现了序列化接口,那么其子类都可以进行序列化
45 */
46 class Foo implements Serializable{
47 public Foo(){
48 System.out.println("foo...");
49 }
50 }
51 class Foo1 extends Foo{
52 public Foo1(){
53 System.out.println("foo1...");
54 }
55 }
56 class Foo2 extends Foo1{
57 public Foo2(){
58 System.out.println("foo2...");
59 }
60 }
61 class Bar{
62 public Bar(){
63 System.out.println("bar");
64 }
65 }
66 class Bar1 extends Bar{
67 public Bar1(){
68 System.out.println("bar1..");
69 }
70 }
71 class Bar2 extends Bar1 implements Serializable{
72 public Bar2(){
73 System.out.println("bar2...");
74 }
75 }