编程进阶：Java小白的序列化Serializable接口

在之前的学习过程中，我们知道了如何使用FileInputStream输入流和FileOutputStream输出流编写程序读写文件。

下面我们来学习一下如何使用序列化和反序列化读写文件。

一、序列化

1.什么是序列化？

序列化就是将对象的状态存储到特定存储介质中的过程，也就是将对象状态转换为可保持或传输格式的过程。

在序列化过程中，会将对象的公有成员、私有成员（包括类名），转换为字节流，然后再把字节流写入数据流，存储到存储介质中，这里说的存储介质通常指文件。

序列化后的对象保存的是二进制状态，这样实现了平台无关性，通过反序列化得到对象，而无需担心数据因平台问题而显示异常。

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

序列化机制允许将实现序列化的Java对象转换为字节序列，这个过程需要借助I/O流来实现。

只有实现了java.io.Serializable接口的类的对象才能被序列化，Serializable表示可串行的，可序列化的（串行化）。

JDK中如String类、包装类和Date类等，都实现了Serializable接口。

二、反序列化

使用反序列化获取对象信息：
1.创建一个对象输出流（ObjectInputStream），它可以包装一个其它类型的输入流。
2.通过对象输入流的readObject()方法读取对象，该方法返回一个object类型的对象，如果程序知道该Java对象的类型，则可以将该对象强制转换成其真实的类型。

 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectOutputStream;

 import bdqn.filedemo.Student;

 /**
  * 用序列化保存对象信息：
  * 1.创建一个对象输出流（ObjectOutputStream），它可以包装一个其它类型的输出流。
  * 2.通过对象输出流的writeObject()方法写对象，也就是输出可序列化对象。
  * @author Administrator
  *
  */
 public class SerializableObj {
 /**
  * 使用序列化将学生对象保存到文件中，实现步骤如下：
  * 1.创建学生类，实现Serializable接口
  * 2.引入相关类
  * 3.创建对象输出流
  * 4.调用writeObject()方法将对象写入文件
  * 5.关闭对象输出流
  * @param args
  */
     public static void main(String[] args) {
         ObjectOutputStream oos = null;
         try {
             //创建ObjectOutputStream输出流
             oos = new ObjectOutputStream(new FileOutputStream("D:\\tengyicheng\\stu.txt"));
             Student stu = new Student("安娜",28,"女");
             //对象序列化，写入输出流
             oos.writeObject(stu);
             System.out.println("录入成功！");
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         finally{
             if (oos!=null) {
                 try {
                     oos.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }

     }

 }

 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;

 import bdqn.filedemo.Student;

 /**
  * 使用反序列化获取对象信息：
  * 1.创建一个对象输出流（ObjectInputStream），它可以包装一个其它类型的输入流。
  * 2.通过对象输入流的readObject()方法读取对象，该方法返回一个object类型的对象，如果程序知道该Java对象的类型，则可以将该对象强制转换成其真实的类型。
  * @author Administrator
  *
  */
 public class DeSerializableObj {

 /**
  * 使用反序列化读取文件中的学生对象：
  * 1.引入相关类
  * 2.创建对象输入流
  * 3.调用readObject()方法读取对象
  * 4.关闭对象输入流。
  * @param args
  */
     public static void main(String[] args) {
         ObjectInputStream ois = null;
         try {
             //创建ObjectInputStream输入流
             ois = new ObjectInputStream(new FileInputStream("D:\\tengyicheng\\stu.txt"));
             Student object = (Student)ois.readObject();
             System.out.println("姓名："+object.getName());
             System.out.println("年龄："+object.getAge());
             System.out.println("性别："+object.getSex());
         } catch (Exception e) {
             e.printStackTrace();
         }
         finally{
             if (ois!=null) {
                 try {
                     ois.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }

     }

 }

 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectOutputStream;
 import java.util.LinkedList;
 import java.util.List;

 import bdqn.filedemo.Student;

 /**
  * 序列化一组对象
  * @author Administrator
  *
  */
 public class SerializableList {

     public static void main(String[] args) {
         ObjectOutputStream oos = null;
         //创建一组学生对象
         Student stu1 = new Student("李小冉",28,"女");
         Student stu2 = new Student("赵丽颖",28,"女");
         Student stu3 = new Student("胡歌",32,"男");
         Student stu4 = new Student("王凯",35,"男");
         //创建一组列表保存
         List<Student> list = new LinkedList<Student>();
         list.add(stu1);
         list.add(stu2);
         list.add(stu3);
         list.add(stu4);
         //创建对象输出流
         try {
             oos = new ObjectOutputStream(new FileOutputStream("D:\\tengyicheng\\stu1.txt"));
             //写入输出流
             oos.writeObject(list);
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         finally{
             if (oos!=null) {
                 try {
                     oos.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }

     }

 }

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.util.LinkedList;
 import java.util.List;

 import bdqn.filedemo.Student;

 /**
  * 反序列化读取一组对象
  * @author Administrator
  *
  */
 public class DeSerializableList {

     public static void main(String[] args) {
         ObjectInputStream ois = null;
         try {
             //创建对象输入流
             ois = new ObjectInputStream(new FileInputStream("D:\\tengyicheng\\stu1.txt"));
             //读取对象
             @SuppressWarnings("unchecked")
             List<Student> stus = (LinkedList<Student>)ois.readObject();
             for (Student stu : stus) {
                 System.out.println("姓名："+stu.getName());
                 System.out.println("年龄："+stu.getAge());
                 System.out.println("性别："+stu.getSex());
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         finally{
             if (ois!=null) {
                 try {
                     ois.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }

     }

 }