一、序列化

1.什麽是序列化？

序列化就是將對象的狀態存儲到特定存儲介質中的過程，也就是將對象狀態轉換為可保持或傳輸格式的過程。

在序列化過程中，會將對象的公有成員、私有成員（包括類名），轉換為字節流，然後再把字節流寫入數據流，存儲到存儲介質中，這裏說的存儲介質通常指文件。

序列化後的對象保存的是二進制狀態，這樣實現了平臺無關性，通過反序列化得到對象，而無需擔心數據因平臺問題而顯示異常。

2.使用序列化保存對象信息

序列化機制允許將實現序列化的Java對象轉換為字節序列，這個過程需要借助I/O流來實現。

只有實現了java.io.Serializable接口的類的對象才能被序列化，Serializable表示可串行的，可序列化的（串行化）。

JDK中如String類、包裝類和Date類等，都實現了Serializable接口。

二、反序列化

使用反序列化獲取對象信息：
1.創建一個對象輸出流（ObjectInputStream），它可以包裝一個其它類型的輸入流。
2.通過對象輸入流的readObject()方法讀取對象，該方法返回一個object類型的對象，如果程序知道該Java對象的類型，則可以將該對象強制轉換成其真實的類型。

 1 import java.io.FileNotFoundException;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 import java.io.ObjectOutputStream;
 5 
 6 import bdqn.filedemo.Student;
 7 
 8 /**
 9  * 用序列化保存對象信息：
10  * 1.創建一個對象輸出流（ObjectOutputStream），它可以包裝一個其它類型的輸出流。
11  * 2.通過對象輸出流的writeObject()方法寫對象，也就是輸出可序列化對象。
12  * @author Administrator
13  *
14  */
15 public class SerializableObj {
16 /**
17  * 使用序列化將學生對象保存到文件中，實現步驟如下：
18  * 1.創建學生類，實現Serializable接口
19  * 2.引入相關類
20  * 3.創建對象輸出流
21  * 4.調用writeObject()方法將對象寫入文件
22  * 5.關閉對象輸出流
23  * @param args
24  */
25     public static void main(String[] args) {
26         ObjectOutputStream oos = null;
27         try {
28             //創建ObjectOutputStream輸出流
29             oos = new ObjectOutputStream(new FileOutputStream("D:\\tengyicheng\\stu.txt"));
30             Student stu = new Student("安娜",28,"女");
31             //對象序列化，寫入輸出流
32             oos.writeObject(stu);
33             System.out.println("錄入成功！");
34         } catch (FileNotFoundException e) {
35             e.printStackTrace();
36         } catch (IOException e) {
37             e.printStackTrace();
38         }
39         finally{
40             if (oos!=null) {
41                 try {
42                     oos.close();
43                 } catch (IOException e) {
44                     e.printStackTrace();
45                 }
46             }
47         }
48 
49     }
50 
51 }

 1 import java.io.FileInputStream;
 2 import java.io.IOException;
 3 import java.io.ObjectInputStream;
 4 
 5 import bdqn.filedemo.Student;
 6 
 7 /**
 8  * 使用反序列化獲取對象信息：
 9  * 1.創建一個對象輸出流（ObjectInputStream），它可以包裝一個其它類型的輸入流。
10  * 2.通過對象輸入流的readObject()方法讀取對象，該方法返回一個object類型的對象，如果程序知道該Java對象的類型，則可以將該對象強制轉換成其真實的類型。
11  * @author Administrator
12  *
13  */
14 public class DeSerializableObj {
15 
16 /**
17  * 使用反序列化讀取文件中的學生對象：
18  * 1.引入相關類
19  * 2.創建對象輸入流
20  * 3.調用readObject()方法讀取對象
21  * 4.關閉對象輸入流。
22  * @param args
23  */
24     public static void main(String[] args) {
25         ObjectInputStream ois = null;
26         try {
27             //創建ObjectInputStream輸入流
28             ois = new ObjectInputStream(new FileInputStream("D:\\tengyicheng\\stu.txt"));
29             Student object = (Student)ois.readObject();
30             System.out.println("姓名："+object.getName());
31             System.out.println("年齡："+object.getAge());
32             System.out.println("性別："+object.getSex());
33         } catch (Exception e) {
34             e.printStackTrace();
35         }
36         finally{
37             if (ois!=null) {
38                 try {
39                     ois.close();
40                 } catch (IOException e) {
41                     e.printStackTrace();
42                 }
43             }
44         }
45 
46     }
47 
48 }

 1 import java.io.FileNotFoundException;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 import java.io.ObjectOutputStream;
 5 import java.util.LinkedList;
 6 import java.util.List;
 7 
 8 import bdqn.filedemo.Student;
 9 
10 /**
11  * 序列化一組對象
12  * @author Administrator
13  *
14  */
15 public class SerializableList {
16 
17     public static void main(String[] args) {
18         ObjectOutputStream oos = null;
19         //創建一組學生對象
20         Student stu1 = new Student("李小冉",28,"女");
21         Student stu2 = new Student("趙麗穎",28,"女");
22         Student stu3 = new Student("胡歌",32,"男");
23         Student stu4 = new Student("王凱",35,"男");
24         //創建一組列表保存
25         List<Student> list = new LinkedList<Student>();
26         list.add(stu1);
27         list.add(stu2);
28         list.add(stu3);
29         list.add(stu4);
30         //創建對象輸出流
31         try {
32             oos = new ObjectOutputStream(new FileOutputStream("D:\\tengyicheng\\stu1.txt"));
33             //寫入輸出流
34             oos.writeObject(list);
35         } catch (FileNotFoundException e) {
36             e.printStackTrace();
37         } catch (IOException e) {
38             e.printStackTrace();
39         }
40         finally{
41             if (oos!=null) {
42                 try {
43                     oos.close();
44                 } catch (IOException e) {
45                     e.printStackTrace();
46                 }
47             }
48         }
49 
50     }
51 
52 }

 1 import java.io.FileInputStream;
 2 import java.io.FileNotFoundException;
 3 import java.io.IOException;
 4 import java.io.ObjectInputStream;
 5 import java.util.LinkedList;
 6 import java.util.List;
 7 
 8 import bdqn.filedemo.Student;
 9 
10 /**
11  * 反序列化讀取一組對象
12  * @author Administrator
13  *
14  */
15 public class DeSerializableList {
16 
17     public static void main(String[] args) {
18         ObjectInputStream ois = null;
19         try {
20             //創建對象輸入流
21             ois = new ObjectInputStream(new FileInputStream("D:\\tengyicheng\\stu1.txt"));
22             //讀取對象
23             @SuppressWarnings("unchecked")
24             List<Student> stus = (LinkedList<Student>)ois.readObject();
25             for (Student stu : stus) {
26                 System.out.println("姓名："+stu.getName());
27                 System.out.println("年齡："+stu.getAge());
28                 System.out.println("性別："+stu.getSex());
29             }
30         } catch (FileNotFoundException e) {
31             e.printStackTrace();
32         } catch (ClassNotFoundException e) {
33             e.printStackTrace();
34         } catch (IOException e) {
35             e.printStackTrace();
36         }
37         finally{
38             if (ois!=null) {
39                 try {
40                     ois.close();
41                 } catch (IOException e) {
42                     e.printStackTrace();
43                 }
44             }
45         }
46         
47     }
48 
49 }

序列化Serializable接口