Java之序列化及反序列化

78 阅读 0 评论 52 点赞

我是靠谱客的博主义气香水，最近开发中收集的这篇文章主要介绍Java之序列化及反序列化，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1.序列化反序列化

Java提供了一种对象【序列化】的机制
用一个字节序列可以表示一个对象：该字节序列包含该对象的数据，对象的类型和对象中存储的属性等信息
该字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息
反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化
对象的数据，对象的类型和对象的存储的属性等信息，都可以用来在内存中创建对象
ObjectOutputStream 与 ObjectInputStream

2.ObjectOutputStream类

      概述：java.io.ObjectOutputStream类，是OutputStream的子类
      特点：可以将Java对象以字节的形式存储到文件中，实现对象的持久保存
      构造方法：
              - public ObjectOutputStream(OutputStream out)：创建一个指定OutputStream的ObjectOutputStream
      成员方法：
              - public final void writeObject(Object obj)：将指定的对象写出
      要求：需要序列化的对象所属的类必须实现序列化接口

创建一个学生类

public class Student implements Serializable {
    public String name ;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

创建一个测试类

public class Tests {
    public static void main(String[] args) throws IOException {

        // 需求：把Student对象写入到指定的文件
        // 1.创建Student对象
        Student s = new Student("张三",19);
        // 2.创建序列化流对象，关联目的地文件路径
        FileOutputStream fos = new FileOutputStream(str);
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 3.写出对象
        oos.writeObject(s);
        System.out.println(s);
        // 4.关闭流
        oos.close();
    }

    static String str = "day13_Properies类&缓冲流&转换流&序列化流&装饰者模式&commons-io工具包\resources\b.txt";
}

3.ObjectInputStream类

          概述：java.io.ObjectInputStream，是InputStream的子类
          特点：可以将文件中对象的字节数据重构成一个对象
          构造方法：
              - public ObjectInputStream(InputStream in)：创建一个指定的InputStream的ObjectInputStream
          成员方法：
              - public final Object readObject()：重构对象

public class Tests {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        // 需求：把s.txt文件中的Student对象，重构出来

        // 1.创建反序列化流对象，关联目的地路径
        FileInputStream fis = new FileInputStream(str);
        ObjectInputStream bis = new ObjectInputStream(fis);
        // 2. 读取/重构对象
        Student s  = (Student) bis.readObject();
        System.out.println(s);
        // 3. 关闭流
        bis.close();
    }


    static String str = "day13_Properies类&缓冲流&转换流&序列化流&装饰者模式&commons-io工具包\resources\b.txt";
}

4.序列化的注意事项1：

1.该类（Student）必须实现import java.io.Serializable接口，Serializable接口是一个标记接口
不实现此接口的类不会使【任何状态】序列化或反序列化，会抛出一个异常：java.io.NotSerializableException
2.该类的所有属性必须是可序列化的

创建一个学生类

public class Student implements Serializable {
    public String name ;
    // 属性age不要序列化，使用transient关键字：瞬时状态【瞬态】
    public transient int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Tests{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

测试类1

public class Tests1 {
    public static void main(String[] args) throws IOException {
        // 需求：把Student对象写出到文件中
        // 1.创建Student对象
        Student student = new Student("张三",20);
        // 2.创建序列化流对象，关联目的地文件路径
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(str));
        // 3.写出对象
        oos.writeObject(student);
        // 4.关闭流
        oos.close();
    }

    static String str = "day13_Properies类&缓冲流&转换流&序列化流&装饰者模式&commons-io工具包\resources\b.txt";
}

测试类2

public class Tests2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 需求：把s.txt文件中的Student对象，重构出来

        // 1.创建反序列化流对象，关联目的地路径
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(str));
        // 2. 读取/重构对象
        Student s = (Student) ois.readObject();
        System.out.println(s);
        // 3. 关闭流
        ois.close();
    }

    static String str = "day13_Properies类&缓冲流&转换流&序列化流&装饰者模式&commons-io工具包\resources\b.txt";
}

5.反序列化的注意事项2:

      1.对于JVM可以反序列化的对象，它必须是能够找到class文件的类
          如果找不到该类的class文件，则抛出一个异常java.lang.ClassNotFoundException
      2.当JVM反序列化对象的时候，能找到class文件，但是class文件在序列化对象之后发生了修改
          那么，反序列化操作也会失败，抛出一个异常：java.io.InvalidClassException
              解决办法：在类中加一个版本号 static final long serialVersionUID = 100L;

学生类

public class Student implements Serializable {
    static final long serialVersionUID = 100L;
    public String name ;
    public int age;
    public String sex;

    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", sex='" + sex + ''' +
                '}';
    }
}

测试类1

public class Tests {
    public static void main(String[] args) throws IOException {

        // 需求：把Student对象写出到文件中
        // 1.创建Student对象
        Student s = new Student("张三",18,"男");
        // 2.创建序列化流对象，关联目的地文件路径
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(str));
        // 3.写出对象
        oos.writeObject(s);
        // 4.关闭流
        oos.close();


    }

    static String str = "day13_Properies类&缓冲流&转换流&序列化流&装饰者模式&commons-io工具包\resources\b.txt";
}

测试类2

public class Tests2 {
    // 需求：把s.txt文件中的Student对象，重构出来
    static String str = "day13_Properies类&缓冲流&转换流&序列化流&装饰者模式&commons-io工具包\resources\b.txt";
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1.创建反序列化流对象，关联目的地路径
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(str));
        // 2. 读取/重构对象
        Student s = (Student) ois.readObject();
        System.out.println(s);

        ois.close();
    }
}

6.案列演示

需求：
1。将存有多个自定义对象的集合序列化操作，保存到list.txt中
2. 反序列化list.txt,并遍历集合，打印对象信息

学生类

public class Students implements Serializable {

    public String name;
    public int age;

    public Students() {
    }

    public Students(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Students{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

测试类

public class Tests {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        FileOutputStream fos = new FileOutputStream(str);
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        ArrayList<Students> list = new ArrayList<>();
        list.add(new Students("张三",20));
        list.add(new Students("李四",18));
        list.add(new Students("王五",32));
        oos.writeObject(list);


        FileInputStream fis = new FileInputStream(str);
        ObjectInputStream ois = new ObjectInputStream(fis);

        ArrayList<Students> list1 = (ArrayList<Students>) ois.readObject();
        for (Students students : list1) {
            System.out.println(students);
        }

        ois.close();
        oos.close();

    }

    static String str = "day13_Properies类&缓冲流&转换流&序列化流&装饰者模式&commons-io工具包\resources\list.txt";
}