序列化与反序列化

序列化

概念

序列化：指将程序中的Java对象，永久保存到磁盘中，相当于写出的过程

对应流方向：out，对应序列化流为ObjectOutputStream

利用ObjectOutputStream,把对象的信息,按照固定的格式转成一串字节值输出并持久保存到磁盘

反序列化

概念

反序列化：指将已经序列化的在文件中保存的数据，读取/恢复到程序中

对应流方向：in，对应反序列化流为ObjectInputStream

利用ObjectInputStream,读取磁盘中之前序列化好的数据,重新恢复成对象

特点与应用场景

  1. 需要序列化的文件必须实现Serializable接口,用来启用序列化功能
  2. 不需要序列化的数据可以修饰成static,原因:static资源属于类资源,不随着对象被序列化输出
  3. 每一个被序列化的文件都有一个唯一的id,如果没有添加此id,编译器会自动根据类的定义信息计算产生一个
  4. 在反序列化时,如果和序列化的版本号不一致,无法完成反序列化
  5. 常用与服务器之间的数据传输,序列化成文件,反序列化读取数据
  6. 常用使用套接字流在主机之间传递对象
  7. 不需要序列化的数据也可以被修饰成transient(临时的),只在程序运行期间在内存中存在,不会被序列化持久保存

使用的流对象

ObjectOutputStream：序列化

ObjectOutputStream 将 Java 对象的基本数据类型写入 OutputStream，通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。

构造方法：ObjectOutputStream(OutputStream out)

创建写入指定 OutputStream 的 ObjectOutputStream

  1. ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(new File("F:\\ready\\1.txt")));

普通方法：writeObject(Object obj)

将指定对象写入ObjectOutputStream

  1. 对象名.weiteObject(需要序列化的对象名);
  2. outputStream.writeObject(student);

ObjectInputStream：反序列化

ObjectInputStream对以前使用ObjectOutputStream写入的基本数据和对象进行反序列化重构对象。

构造方法:
ObjectInputStream(InputStream in) 创建从指定 `InputStream读取的ObjectInputStream

普通方法:
readObject() 从 ObjectInputStream 读取对象

  1. ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(new File("F:\\ready\\1.txt")));
  1. Object 对象名 = 反序列化的对象名.readObject();
  2. Object o = inputStream.readObject();

示例代码

创建序列化对象

  1. package cd.tedu.serializable;
  3. import java.io.Serializable;
  5. /**
  6.  * 封装学生对象，用于测试序列化
  7.  * 若想要完成序列化，必须实现可序列化接口，否则报错
  8.  * 报错信息
  9.  * java.io.NotSerializableException: cd.tedu.serializable.Student
  10.  * Serializable接口为空接口，其中不存在方法
  11.  * 作用：用于当作标记，标记这个类的对象可以被序列化输出
  12.  */
  14. public class Student implements Serializable {
  15.     private static final long serialVersionUID = 250L;
  16.     private String name;
  17.     private int age;
  18.     private String address;
  19.     private char gender;
  20.     private int id;
  22.     public Student() {
  23.         System.out.println("无惨");
  24.     }
  26.     public Student(String name, int age, String address, char gender) {
  27.         System.out.println("群惨");
  28.         this.name = name;
  29.         this.age = age;
  30.         this.address = address;
  31.         this.gender = gender;
  32.     }
  34.     public String getName() {
  35.         return name;
  36.     }
  38.     public void setName(String name) {
  39.         this.name = name;
  40.     }
  42.     public int getAge() {
  43.         return age;
  44.     }
  46.     public void setAge(int age) {
  47.         this.age = age;
  48.     }
  50.     public String getAddress() {
  51.         return address;
  52.     }
  54.     public void setAddress(String address) {
  55.         this.address = address;
  56.     }
  58.     public char getGender() {
  59.         return gender;
  60.     }
  62.     public void setGender(char gender) {
  63.         this.gender = gender;
  64.     }
  66.     @Override
  67.     public String toString() {
  68.         return "Student{" +
  69.                 "name='" + name + '\'' +
  70.                 ", age=" + age +
  71.                 ", address='" + address + '\'' +
  72.                 ", gender=" + gender +
  73.                 '}';
  74.     }
  75. }

将Student类进行序列化与反序列化

  1. package cd.tedu.serializable;
  3. import java.io.*;
  5. /**
  6.  * 测试序列化与反序列化
  7.  * 序列化：指将程序中的Java对象，永久保存到磁盘中，相当于写出的过程
  8.  * 对应流方向：out，对应序列化流为ObjectOutputStream
  9.  * 反序列化：指将已经序列化的在文件中保存的数据，读取/恢复到程序中
  10.  * 对应流方向：in，对应反序列化流为ObjectInputStream
  11.  */
  13. public class TestSerializable {
  14.     public static void main(String[] args) {
  15.         method();//测试序列化
  16.         method1();//测试反序列化
  17.     }
  19.     private static void method() {
  20.         ObjectOutputStream outputStream =null;
  21.         try {
  22.             //ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(new File("F:\\ready\\1.txt")));
  23.             outputStream = new ObjectOutputStream(new FileOutputStream("F:\\ready\\1.txt"));
  24.             Student student = new Student("埼玉",22,"广岛",'男');
  26.             outputStream.writeObject(student);
  27.             System.out.println("恭喜你！序列化成功");
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.             System.out.println("很抱歉！序列化失败");
  31.         } finally {
  32.             try {
  33.                 outputStream.close();
  34.             } catch (IOException e) {
  35.                 e.printStackTrace();
  36.             }
  37.         }
  38.     }
  40.     private static void method1() {
  41.         ObjectInputStream inputStream = null;
  42.         try {
  43.             //inputStream = new ObjectInputStream(new FileInputStream(new File("F:\\ready\\1.txt")));
  44.             inputStream = new ObjectInputStream(new FileInputStream("F:\\ready\\1.txt"));
  45.             Object o = inputStream.readObject();
  46.             System.out.println(o);
  47.             System.out.println("反序列化成功");
  48.         } catch (Exception e) {
  49.             System.out.println("反序列化失败");
  50.             e.printStackTrace();
  51.         }finally {
  52.             try {
  53.                 inputStream.close();
  54.             } catch (IOException e) {
  55.                 e.printStackTrace();
  56.             }
  57.         }
  58.     }
  59. }

报错信息

NotSerializableException

原因：要序列化对象所在的类并没有实现序列化接口

解决方法：实现序列化接口

  1. public class 类名 implements Serializable {}

InvalidClassException:

原因：本次反序列化时使用的UID与序列化时的UID不匹配

解决方法：反序列化时的UID与序列化时的UID要保持一致，或者测试时一次序列操作对应一次反序列化操作,否则不匹配就报错

  1. private static final long serialVersionUID = uid编号;

文件复制

示例代码

  1. package cd.tedu.io;
  3. import java.io.*;
  4. import java.util.Scanner;
  6. public class TestCopyFile {
  7.     public static void main(String[] args) {
  8.         System.out.print("请输入要复制的文件路径:");
  9.         String f = new Scanner(System.in).nextLine();
  10.         System.out.print("请输入目标文件路径:");
  11.         String t = new Scanner(System.in).nextLine();
  12.         ZFCopy(f,t);//字符流文件复制
  13.         ZJCopy(f,t);//字节流文件复制
  15.     }
  17.     private static void ZFCopy(String f, String t) {
  18.         Reader in = null;
  19.         Writer out = null;
  20.         try {
  21.             in  = new BufferedReader(new FileReader(f));
  22.             out = new BufferedWriter(new FileWriter(t));
  23.             int b;
  24.             while ((b = in.read()) != -1){
  25.                 System.out.println(b);
  26.                 out.write(b);
  27.                 out.flush();
  28.             }
  29.             System.out.println("复制成功");
  30.         } catch (Exception e) {
  31.             System.out.println("复制失败");
  32.             e.printStackTrace();
  33.         } finally {
  34.             /*
  35.             关流顺序：最后创建的流先关闭，多条关流语句需要各自try-catch
  36.              */
  37.             try {
  38.                 out.close();
  39.             } catch (IOException e) {
  40.                 e.printStackTrace();
  41.             }
  42.             try {
  43.                 in.close();
  44.             } catch (IOException e) {
  45.                 e.printStackTrace();
  46.             }
  47.         }
  48.     }
  50.     private static void ZJCopy(String f, String t) {
  51.         InputStream in = null;
  52.         OutputStream out = null;
  53.         try {
  54.             in = new BufferedInputStream(new FileInputStream(f));
  55.             out = new BufferedOutputStream(new FileOutputStream(t));
  56.             int b;
  57.             while ((b = in.read()) != -1){
  58.                 System.out.println(b);
  59.                 out.write(b);
  60.             }
  61.             System.out.println("复制成功");
  62.         } catch (Exception e) {
  63.             System.out.println("复制失败");
  64.             e.printStackTrace();
  65.         } finally {
  66.             try {
  67.                 out.close();
  68.             } catch (IOException e) {
  69.                 e.printStackTrace();
  70.             }
  71.             try {
  72.                 in.close();
  73.             } catch (IOException e) {
  74.                 e.printStackTrace();
  75.             }
  76.         }
  78.     }
  79. }