Java - 序列化与反序列化

序列化和反序列化

[java]  view plain  copy

1. 对象序列化  
2.     将对象转换为字节流保存起来,并在以后还原这个对象,这种机制叫做对象序列化  
3. 序列化和反序列化  
4.     序列化是将内存中的对象保存到文件中  
5.     反序列化是将对象从文件加载到内存中  
6.     如果一个对象被序列化,那么引用这个对象的其他对象也将被序列化  
7.     如果一个对象被反序列化,那么引用这个对象的其他对象也将被恢复  
8. 一个类如果想要被序列化,则应该实现java.io.Serializable接口,  
9.     该接口中没有任何方法,只是一个标识性接口(Marker Interface),  
10.     当一个类实现了Serializable接口,就表示这个类的对象可以被序列化  
11. 一个对象被序列化,只能保存非静态成员变量,其他的都不能保存  
12.     静态成员变量不能保存的原因是,静态成员变量不属于对象是属于类本身  
13.     如果成员变量是一个对象,那么这个对象的成员变量也会被保存  
14. 一个对象中的对象不可以被序列化,那么这个对象被序列化将会失败,  
15.     并且抛出NotSerializableException  
16.     如果这个对象必须被序列化,我们可以把对象中的对象标记为transient(瞬时的)  
17. 如果一个类可以被序列化,那么所有子类也可以被序列化  

利用java自身实现序列化和反序列化

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.ObjectInputStream;  
6. import java.io.ObjectOutputStream;  
7. import java.io.Serializable;  
8.   
9. /** 
10.  * Java自身实现序列化和反序列化 
11.  */  
12. public class Test {  
13.     public static void main(String[] args) throws Exception {  
14.         Person p1 = new Person("lwc", 18, "陕西");  
15.         Person p2 = new Person("tom", 19, "河南");  
16.         Person p3 = new Person("cat", 20, "北京");  
17.         // 序列化  
18.         FileOutputStream fos = new FileOutputStream("person.txt");  
19.         ObjectOutputStream oos = new ObjectOutputStream(fos);  
20.         oos.writeObject(p1);  
21.         oos.writeObject(p2);  
22.         oos.writeObject(p3);  
23.         // 反序列化  
24.         FileInputStream fis = new FileInputStream("person.txt");  
25.         ObjectInputStream ois = new ObjectInputStream(fis);  
26.         for (int i = 0; i < 3; i++) {  
27.             Person p = (Person) ois.readObject();// 把对象写入文件中  
28.             System.out.println(p.name + "," + p.age + "," + p.address);  
29.         }  
30.         oos.close();  
31.         ois.close();  
32.     }  
33. }  
34.   
35. // 要想使某个类序列化,这个类必须实现Serializable接口  
36. class Person implements Serializable {  
37.     private static final long serialVersionUID = -7147436129983998671L;  
38.     // 被static,transient修饰的变量不会被保存到文件  
39.     static int number;  
40.     String name;  
41.     int age;  
42.     transient String address;  
43.   
44.     public Person(String name, int age, String address) {  
45.         super();  
46.         this.name = name;  
47.         this.age = age;  
48.         this.address = address;  
49.     }  
50. }  

自定定义实现序列化和反序列化

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.ObjectInputStream;  
6. import java.io.ObjectOutputStream;  
7. import java.io.Serializable;  
8.   
9. /** 
10.  * 自定定义实现序列化和反序列化 
11.  */  
12. public class Test {  
13.     public static void main(String[] args) throws Exception {  
14.         Person p1 = new Person("lwc", 18, "陕西");  
15.         Person p2 = new Person("tom", 19, "河南");  
16.         Person p3 = new Person("cat", 20, "北京");  
17.         FileOutputStream fos = new FileOutputStream("person.txt");  
18.         ObjectOutputStream oos = new ObjectOutputStream(fos);  
19.         oos.writeObject(p1);  
20.         oos.writeObject(p2);  
21.         oos.writeObject(p3);  
22.         FileInputStream fis = new FileInputStream("person.txt");  
23.         ObjectInputStream ois = new ObjectInputStream(fis);  
24.         for (int i = 0; i < 3; i++) {  
25.             Person p = (Person) ois.readObject();// 把对象写入文件中  
26.             System.out.println(p.name + "," + p.age + "," + p.address);  
27.         }  
28.         oos.close();  
29.         ois.close();  
30.     }  
31. }  
32.   
33. class Person implements Serializable {  
34.     private static final long serialVersionUID = -7147436129983998671L;  
35.     static int number;  
36.     String name;  
37.     int age;  
38.     transient String address;  
39.   
40.     public Person(String name, int age, String address) {  
41.         super();  
42.         this.name = name;  
43.         this.age = age;  
44.         this.address = address;  
45.     }  
46.   
47.     /* 
48.      * 如果序列化/反序列化的类自身定义了writeObject()和readObject(), 
49.      * 那么我们可以更底层方式控制序列化/反序列化的过程, 
50.      * writeObject()和readObject()在序列化/反序列化的时候将自动调用 
51.      * 如果不在writeObject()和readObject()中定义代码,只有成员变量保存到文件中,值不保存 
52.      * 要想值也保存,必须在writeObject()和readObject()中自定义代码 
53.      */  
54.     private void writeObject(java.io.ObjectOutputStream out) throws Exception {  
55.         out.writeUTF(name);  
56.         out.writeInt(age);  
57.     }  
58.   
59.     private void readObject(java.io.ObjectInputStream in) throws Exception {  
60.         name = in.readUTF();  
61.         age = in.readInt();  
62.     }  
63. }