文章目录

• 前言
• 什么是对象流？
• 基本介绍
• ObjectOutputStream
• ObjectInputStream
• 对象处理流的使用细节

前言

处理流：是对一个已存在的流进行处理和封装，通过所封装的流的功能调用实现对数据的操作。而处理流中也有不同的分类，此片介绍的是处理流中的对象流。

如果对处理流流有疑问，可查看此博客或自行百度！
Java之节点流和处理流

什么是对象流？

对象流用于存储和读取基本数据类型数据和对象的处理流。它的强大之处在于可以把java中的对象写入数据源中，也能把对象从数据源中还原回来。为了让对象持久化（把对象存储到本地），可以使用java的对象流处理对象，把对象的内容写到本地存储的文件中，也可以从本地文件中读取出来。

比如说：将100（int/整形类型）和== 你好（String/字符串类型）== 写入某文本，写入的时候需要保持文件的100为int类型，你好为String类型，此时就需要用到对象流。（在保持一个数据值的时候，能够把它的数据类型保存起来）

也就是常说的序列化和反序列化。

• 序列化：一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型（保存一个对象的时候，保存数据的值和数据类型就叫序列化）
• 反序列化：将序列化对象写入文件之后，可以从文件中读取出来（恢复数据的时候，恢复数据的值和数据类型）

如果需要让某个对象支持序列化支持，则必须让其类是可序列化的。
为了让某个类是可序列化，该类必须实现如下两个接口之一：

• Serializable：提供的通用数据保存和读取的接口（标记接口，没有方法）
• Externalizable：该接口有方法需要实现，一般使用Serializable接口实现

基本介绍

• ObjectOutputStream：提供序列化功能
• ObjectInputStream：提供反序列化功能

功能:：提供了对基本类型或对象类型的序列化和反序列化的方法

根据图可知，这两个类提供的构造器中采用了修饰器模式（传入的是各自父类的子类的实现对象，用什么方式操作，就传什么）

ObjectOutputStream

把对象转成字节数据的输出到文件中保存，对象的输出过程称为序列化，可实现对象的持久存储。

构造器

具体操作方法可以查看JDK文档或者百度
JDK8英文在线文档
JDK8中文在线文档

使用ObjectOutputStream序列化基本数据类型和一个Dog对象（自定义），并保存到data.dat文件中

序列化后，保存的文件格式不是纯文本的，而是按照它的格式来保存

• Integer实现了Serializable接口（int自动装箱）
• Boolean实现了Serializable接口（boolean自动装箱）
• Character实现了Serializable接口（char自动装箱）
• Double实现了Serializable接口（double自动装箱）
• String实现了Serializable接口
  

注意：这里ObjectOutputStream_ 和Dog文件在同一目录下，如果不在同一个目录下，则需要导包！

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;/*** 演示使用ObjectOutputStream的使用*/
public class ObjectOutputStream_ {public static void main(String[] args) {String filePath = "E:\\data.dat";//ObjectOutputStream os = null;try {os = new ObjectOutputStream(new FileOutputStream(filePath));//序列化数据E:\\data.datos.writeInt(100);//int -> Integer(自动装箱)os.writeBoolean(true);//boolean -> Boolean(自动装箱)os.writeChar('a');//char -> Characteros.writeDouble(3.14);//double -> Doubleos.writeUTF("hello");//String//保存自定义对象os.writeObject(new Dog("jack", 4));} catch (IOException e) {e.printStackTrace();} finally {try {os.close();//释放资源System.out.println("数据保存完毕（序列化）");} catch (IOException e) {e.printStackTrace();}}}
}

• Dog类

import java.io.Serializable;public class Dog implements Serializable {private String name;private int age;public Dog(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;}
}

文件打开乱码属于正常现象，此代码执行之后文件中内容：
 w d a@ 窺雲 hellosr com.chapter19.outputstream_.DogP戶嶏+/> I ageL namet Ljava/lang/String;xp t jack

ObjectInputStream

反序列化流，将之前使用 ObjectOutputStream 序列化的原始数据恢复为对象，以流的方式读取对象。

构造器

具体操作方法可以查看JDK文档或者百度
JDK8英文在线文档
JDK8中文在线文档

• 读取（反序列化）的顺序要和保存数据（序列化）的顺序一致，否则会出现异常。

恢复ObjectOutputStream输出到文件中的数据和类型，恢复到程序中（反序列化）

注意：自定义类读取时,需要将定义的类拷贝到工程（并且公有化）或者导包

• 这里我使用的是导包

import com.chapter19.outputstream_.Dog;import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;public class ObjectInputStream_ {public static void main(String[] args) {String filePath = "E:\\data.dat";//指定反序列化的文件ObjectInputStream oi = null;try {oi = new ObjectInputStream(new FileInputStream(filePath));System.out.println(oi.readInt());System.out.println(oi.readBoolean());System.out.println(oi.readChar());System.out.println(oi.readDouble());System.out.println(oi.readUTF());Object obj = oi.readObject();System.out.println(obj);System.out.println("运行类型" + obj.getClass());Dog o1 = (Dog) obj;System.out.println(o1.getName());} catch (IOException | ClassNotFoundException e) {e.printStackTrace();} finally {try {oi.close();} catch (IOException e) {e.printStackTrace();}}}
}

控制台输出如下：
a
3.14
hello
com.chapter19.outputstream_.Dog@6f496d9f
运行类型class com.chapter19.outputstream_.Dog
jack

对象处理流的使用细节

1. 读写顺序要一致，如果顺序出错，则会抛出异常

2. 要求序列化或反序列化对象，需要实现Serializable接口

3. 序列化的类中建议添加SerialVersionUID，提高版本的兼容性
   
   当文件中添加新的内容需要执行时，JVM会认为这个文件只是这个个版本的修改版或升级版，而不会认为是一个新的类（与游戏更新类似）

4. 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员（被transient修饰的变量不参与序列化和反序列化）

5. 序列化对象时，要求里面属性的类型也需要实现序列化接口（int、char、double等会自动封装类型）

6. 序列化具有可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化