7.对象序列化流

1.概述

对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象

这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型，对象的数据和对象中存储的属性等信息

字节序列写到文件之后，相当于文件中持久保存了一个对象的信息

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。

要实现序列化和反序列化就要使用对象序列化流和对象反序列化流：

• 对象序列化流：ObjectOutputStream
• 对象反序列化流：ObjectInputStream

2. 对象序列化流

对象序列化流：ObjectOutputStream

• 将Java对象的原始数据类型和图形写入OutputStream。可以使用ObjectInputStream读取（重构）对象。可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象。

构造方法：

• ObjectOutputStream(OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream

序列化对象的方法

• void writeObject(Object obj):将指定的对象写入ObjectOutputStream

注意：

• 一个对象想要被序列化，该对象所属的类必须实现Serializable接口（需导包）
• Serializable是一个标记接口，实现该接口，不需要重写任何方法

代码

//Student类
package Study08;

import java.io.Serializable;

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

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.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;
    }
}

//objectOutputStreamDemo
package Study08;

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

/*
构造方法：
- `ObjectOutputStream(OutputStream out`):创建一个写入指定的`OutputStream`的`ObjectOutputStream`

序列化对象的方法
- `void writeObject(Object obj)`:将指定的对象写入`ObjectOutputStream`

NotSerializableException:抛出一个实例需要一个Serializable接口。 序列化运行时或实例的类可能会抛出此异常。
Serializable:类的序列化由实现java.io.Serializable接口的类启用。 不实现此接口的类将不会使任何状态序列化或反序列化。
*/
public class objectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //- `ObjectOutputStream(OutputStream out`):创建一个写入指定的`OutputStream`的`ObjectOutputStream`
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Study\\oos.txt"));

        //创建对象
        Student s = new Student("迪丽热巴",18);

        //`void writeObject(Object obj)`:将指定的对象写入`ObjectOutputStream`
        oos.writeObject(s);

        //释放资源
        oos.close();
    }
}

3.对象反序列化流

对象反序列化流：ObjectInputStream

• ObjectInputStream：反序列化先前使用ObjectOutputStream编写的原始数据和对象

构造方法：

• ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream

反序列化对象的方法：

• Object readObject():从ObjectInputStream读取一个对象

代码：

package Study08;

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

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

反序列化对象的方法：
- `Object readObject()`:从`ObjectInputStream`读取一个对象*/
public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //- `ObjectInputStream(InputStream in)`:创建从指定的`InputStream`读取的`ObjectInputStream`
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Study\\oos.txt"));
        //- `Object readObject()`:从`ObjectInputStream`读取一个对象
        Object o = ois.readObject();
        //向下转型并输出
        Student s = (Student) o;
        System.out.println(s.getName() + "," + s.getAge());
        //释放资源
        ois.close();
    }
}

4. serialVersionUID&transient

三个问题

• 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题？

  • 会出问题，抛出InvalidClassException异常

• 如果出问题了，如何解决？

  • 给对象所属的类加一个serialVersionUID值（被private修饰）

    •   private static final long serialVersionUID = 42L;
      

• 如果一个对象的某个成员变量的值不想被序列化，又该如何实现呢？

  • 给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程

代码：

//Student类
package Study08;

import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID = 42L;
    private String name;
//    private int age;
      private transient int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.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;
    }

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

package Study08;

import java.io.*;

/*三个问题

- 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题？
java.io.InvalidClassException:
当序列化运行时检测到类中的以下问题之一时抛出。
类的串行版本与从流中读取的类描述符的类型不匹配
该类包含未知的数据类型
该类没有可访问的无参数构造函数

Study08.Student;local class incompatible:
stream classdesc serialVersionUID = 4019092224222280913,
local class serialVersionUID = 2822047369298212305

- 如果出问题了，如何解决？
            给对象所属的类增加一个值：private static final long serialVersionUID = 42L;

- 如果一个对象的某个成员变量的值不想被序列化，又该如何实现呢？
            private transient int age;
*/
public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        write();
        read();
    }

    //反序列化
    private static void read() throws IOException, ClassNotFoundException {
        //- `ObjectInputStream(InputStream in)`:创建从指定的`InputStream`读取的`ObjectInputStream`
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Study\\oos.txt"));
        //- `Object readObject()`:从`ObjectInputStream`读取一个对象
        Object o = ois.readObject();
        //向下转型并输出
        Student s = (Student) o;
        System.out.println(s.getName() + "," + s.getAge());
        //释放资源
        ois.close();
    }

    //序列化
    private static void write() throws IOException {
        //- `ObjectOutputStream(OutputStream out`):创建一个写入指定的`OutputStream`的`ObjectOutputStream`
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Study\\oos.txt"));
        //创建对象
        Student s = new Student("迪丽热巴", 18);
        //`void writeObject(Object obj)`:将指定的对象写入`ObjectOutputStream`
        oos.writeObject(s);
        //释放资源
        oos.close();
    }
}