java io流与序列化反序列化

java的io是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。

序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

下面是一个实例，通过例子来将以上来简化学习：

1.先创建一个学生类来实现serialization：

 1 package com.etc;
 2
 3 import java.io.Serializable;
 4
 5 public class Student implements Serializable{
 6     private int id;
 7     private String name;
 8     private char sex;
 9
10
11     public Student() {
12         super();
13     }
14     public Student(int id, String name, char sex) {
15         super();
16         this.id = id;
17         this.name = name;
18         this.sex = sex;
19     }
20     public int getId() {
21         return id;
22     }
23     public void setId(int id) {
24         this.id = id;
25     }
26     public String getName() {
27         return name;
28     }
29     public void setName(String name) {
30         this.name = name;
31     }
32     public char getSex() {
33         return sex;
34     }
35     public void setSex(char sex) {
36         this.sex = sex;
37     }
38
39     public String show() {
40         return "Student [id=" + id + ", name=" + name + ", sex=" + sex + "]";
41     }
42
43
44 }

2.通过控制台将建立的学生对象保存到集合中，序列化集合写到文件中，在读文件反序列化集合，将学生对象添加到学生集合中，遍历集合

 1 package com.etc;
 2
 3 import java.io.BufferedReader;
 4 import java.io.File;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.InputStreamReader;
 8 import java.io.ObjectOutputStream;
 9 import java.util.ArrayList;
10 import java.util.List;
11
12 public class 序列化学生集合 {
13     public static void main(String[] args) throws IOException {
14         //创建集合添加学生
15         List<Student> list=new ArrayList<>();
16         //创建控制台输入流，将文件保存到src/student.dat下
17         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("src/student.dat")));
18         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
19         //获取控制台信息
20         System.out.println("如果录入信息请输入‘y’，否则输入‘n’");
21         String str = br.readLine();
22         boolean flag = true;
23         //循环判断是否继续输入信息
24         while (flag) {
25             Student s = new Student();//实例化一个学生对象
26             //获取各个信息
27             System.out.println("请输入学号");
28             String str1 = br.readLine();
29             System.out.println("请输入姓名");
30             String str2 = br.readLine();
31             System.out.println("请输入性别");
32             String str3 = br.readLine();
33             //将值传入到学生对象中
34             s.setId(Integer.parseInt(str1));
35             s.setName(str2);
36             s.setSex(str3.charAt(0));
37             list.add(s);//添加学生到集合中
38             System.out.println("如果录入信息请输入‘y’，否则输入‘n’");
39             String str8 = br.readLine();
40             //判断是否继续录入
41             if (str8.equals("y")) {
42                 flag = true;
43             } else {
44                 flag = false;
45                 System.out.println("录入结束");
46             }
47         }
48
49         for (Student student : list) {
50             System.out.println(student.show());
51         }
52         oos.writeObject(list);//将信息写入文件中
53         oos.close();
54     }
55 }

3.反序列化

 1 package com.etc;
 2
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.io.InputStreamReader;
 9 import java.io.ObjectInputStream;
10 import java.util.ArrayList;
11 import java.util.List;
12
13 public class 反序列化 {
14     public static void main(String[] args) throws IOException, ClassNotFoundException {
15         //创建反序列化集合
16         List<Student> arrayList=new ArrayList<>();
17         //读文件
18         ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("src/student.dat")));
19         //创建集合保存反序列化学生对象
20         ArrayList List=(ArrayList) ois.readObject();
21
22         //遍历反序列化集合添加到学生集合中
23         for (Object object : List) {
24             arrayList.add((Student) object);
25         }
26         //遍历学生集合
27         for (Student student : arrayList) {
28             System.out.println(student.show());
29         }
30
31     }
32 }

反序列化时，一定要想清楚对方传给自己的是什么信息，例如传来的集合，就新建集合，来将反序列化信息来保存，再通过集合的类型，来将传过来的信息进行重组添加到集合中，最后遍历集合。

原文地址：https://www.cnblogs.com/LiuOOP/p/10992344.html