一、理解对象流及序列化机制
1.对象流作用
用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到文件源中（序列化），也能把对象从文件源中还原回来（反序列化）
2.序列化机制理解
首先我们要了解什么是序列化机制？
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从
而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传
输到另一个网络节点。
当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
注意：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
3.序列化机制的好处
可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
4.序列化注意事项
首先，如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可
序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。
- Serializable（主要实现这个接口）
- Externalizable
否则，会抛出NotSerializableException异常
凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：
/*
用来表明类的不同版本间的兼容性。
简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自
动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议，
显式声明。
*/
private static final long serialVersionUID;
二、操作步骤
1.使用对象流序列化操作
1. 创建节点输出流（FileOutputStream）
2. 创建对象流（ObjectOutputStream）
3. 调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象
4. 注意写出一次，操作flush()一次
5. 关闭流
代码展示：
public class ObjectTest {
@Test
public void test(){
ObjectOutputStream oos = null;
try {
//1.创建节点流(文件流)
FileOutputStream fos = new FileOutputStream("object.txt");
//2.创建对象流,实现序列化操作
oos = new ObjectOutputStream(fos);
//3.调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象
oos.writeObject(new String("对象流很简单！"));
//4.注意写出一次，操作flush()一次
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (oos != null){
//5.关闭流
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
注意：输出序列化对象后，需要进行反序列化操作才能得到内容！否则就是乱码！
2.使用对象流反序列化操作
1. 创建节点输出流（FileInputStream）
2. 创建对象流（ObjectInputStream）
3. 调用 ObjectOutputStream 对象的 readObject() 方法输出可序列化对象
4. 关闭流
代码展示：
public class ObjectTest {
@Test
public void test2(){
ObjectInputStream ois = null;
try {
//1.创建节点输入流(FileInputStream)
FileInputStream fis = new FileInputStream("object.txt");
//2. 创建对象流（ObjectInputStream）
ois = new ObjectInputStream(fis);
//3.调用 ObjectOutputStream 对象的 readObject() 方法输出可序列化对象
Object obj = ois.readObject();
String str = (String) obj;
System.out.println(str);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
//4.关闭流
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个
引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的
Field 的类也不能序列化
假设我们想要通过对象流输出自定义的对象（Person）
代码展示：
/*
我们必须将自定义的对象，实现Serializable接口，
否则该对象不能进行序列化操作！
*/
public class Person implements Serializable{
//序列化版本标识符的静态变量
private static final long serialVersionUID = 12321312331231L;
private String name;
private int age;
public Person() {
}
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 PersonTest {
@Test
public void test(){
ObjectOutputStream oos = null;
try {
//1.创建节点流
FileOutputStream fos = new FileOutputStream("Person.txt");
//2.创建对象流
oos = new ObjectOutputStream(fos);
//3.调用方法，进行序列化操作
oos.writeObject(new Person("Xuzhibin",20));
//4.刷新
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (oos != null){
//5.关闭
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void test1(){
ObjectInputStream ois = null;
try {
//1.创建节点流
FileInputStream fis = new FileInputStream("Person.txt");
//2.创建对象流
ois = new ObjectInputStream(fis);
//3.调用方法进行反序列化操作
Object obj = ois.readObject();
Person p = (Person) obj;
System.out.println(p);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
//4.关闭流
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
先运行序列化操作，再运行非序列化操作，得到结果如下，大功告成！：
