对象流和序列化

对象流：ObjectInputStream 和 ObjectOutputStream
用于存储和读取基本数据类型数据或对象的处理流。它可以将java中的对象写入到数据源中，也可以把对象从数据源中还原出来。

• 序列化：用ObjectOutputStream类保存基本数据类型和对象类型。
• 反序列化：用ObjectInputStream类读取基本数据类型和对象类型。

注：不能序列化被static和transient的成员属性

对象序列化机制允许把内存中的java对象转化成平台无关的二进制流，从而允许把这种二进制流保存到磁盘上，或通过网络将这种二进制流传到另一个网络节点。当其他程序了获取二进制流便可以恢复。

• 若一个对象想被序列化需要继承Serializable接口
• 并提供全局常量：serialVersionUID
• 除了当前类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型可序列化）。

package JavaFour;

import java.io.Serializable;

/**
 * @ClassName : SerializablePerson  //类名
 * @Description : 用来被序列化的对象  //描述
 * @Author : Gao //作者
 * @Date: 2022/3/8  19:22
 */
/*
若需要序列化的对象则需要实现Serializable，并提供一个序列号，且其中的属性也应该是可以被序列化的
 */
public class SerializablePerson implements Serializable {

    static final long serialVersionUID = 48887787882L;


    private String name;
    private int age;

    public SerializablePerson() {
    }

    public SerializablePerson(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 "SerializablePerson{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

对象的序列化和反序列化操作

• 若某个类实现了 Serializable 接口，该类的对象就是可序列化的：

  ①创建一个 ObjectOutputStream
  ②调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象
  ③注意写出一次，操作flush()一次

• 反序列化

  ①创建一个 ObjectInputStream
  ②调用 readObject() 方法读取流中的对象

package JavaFour;

import org.junit.Test;

import java.io.*;

/**
 * @ClassName : SerializableTest  //类名
 * @Description : 序列化测试  //描述
 * @Author : Gao //作者
 * @Date: 2022/3/8  19:15
 */
/*
所谓序列化，就是讲java中的对象或属性，转换成二进制流的方式，存储在磁盘中或在网络之间传输。
 */
public class SerializableTest {
    //将对象序列化
    @Test
    public void test() {
        //创建一个对象流对象
        ObjectOutputStream objectOutputStream = null;
        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream("test.dat"));
            //将一个字符串类对象序列化
            objectOutputStream.writeObject(new String("高从慧为啥这么帅"));
            objectOutputStream.flush();
            //将一个自定义类的对象序列化
            objectOutputStream.writeObject(new SerializablePerson("gaoconghui",21));
            objectOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (objectOutputStream!=null){
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
    /*
    反序列化
     */
    @Test
    public void test1(){
        ObjectInputStream objectInputStream = null;
        try {
            objectInputStream = new ObjectInputStream(new FileInputStream("test.dat"));
            //读取被序列化的字符串对象
            Object o = objectInputStream.readObject();
            String str = (String)o;
            System.out.println(str);
            //读取被序列化的自定义对象
            Object o1 = objectInputStream.readObject();
            SerializablePerson serializablePerson = (SerializablePerson) o1;
            System.out.println(serializablePerson.getName());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (objectInputStream!=null){
                try {
                    objectInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}