[TOC]
# 简介
用于从流中读取对象的
操作流 ObjectInputStream 称为 反序列化流
用于向流中写入对象的操作流 ObjectOutputStream 称为 序列化流
* 特点:用于操作对象。可以将对象写入到文件中,也可以从文件中读取对象
**序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化,将数据分解成字节流,以便存储在文件中或在网络上传输。**
## 对象序列化流ObjectOutputStream
ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取(重构)对象。通过在流中使用文件可以实现对象的持久存储。
注意:只能将支持 java.io.Serializable 接口的对象写入流中
**构造方法**
~~~
ObjectOutputStream(OutputStream out)
创建写入指定OutputStream的ObjectOutputStream
~~~
**方法**
~~~
void writeObject(Object obj)
将指定的对象写入ObjectOutputStream
~~~
~~~
public static void main(String[] args) throws IOException, ClassNotFoundException {
/*
* 将一个对象存储到持久化(硬盘)的设备上。
*/
writeObj();//对象的序列化。
}
public static void writeObj() throws IOException {
//1,明确存储对象的文件。
FileOutputStream fos = new FileOutputStream("tempfile\\obj.object");
//2,给操作文件对象加入写入对象功能。
ObjectOutputStream oos = new ObjectOutputStream(fos);
//3,调用了写入对象的方法。
oos.writeObject(new Person("wangcai",20));
//关闭资源。
oos.close();
}
~~~
Person类
~~~
public class Person implements Serializable {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
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 "Person [name=" + name + ", age=" + age + "]";
}
}
~~~
## 对象反序列化流ObjectInputStream
ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。支持 java.io.Serializable接口的对象才能从流读取
**构造方法**
~~~
ObjectInputStream(InputStream in)
创建从指定InputStream读取的ObjectInputStream
~~~
**方法**
~~~
Object readObject() 从ObjectInputStream读取对象
~~~
~~~
public static void main(String[] args) throws IOException, ClassNotFoundException {
readObj();//对象的反序列化。
}
public static void readObj() throws IOException, ClassNotFoundException {
//1,定义流对象关联存储了对象文件。
FileInputStream fis = new FileInputStream("tempfile\\obj.object");
//2,建立用于读取对象的功能对象。
ObjectInputStream ois = new ObjectInputStream(fis);
Person obj = (Person)ois.readObject();
System.out.println(obj.toString());
}
~~~
## 序列化接口
当一个对象要能被序列化,这个对象所属的类必须实现Serializable接口。否则会发生异常NotSerializableException异常。
同时当反序列化对象时,如果对象所属的class文件在序列化之后进行的修改,那么进行反序列化也会发生异常InvalidClassException。发生这个异常的原因如下:
* 该类的序列版本号与从流中读取的类描述符的版本号不匹配
* 该类包含未知数据类型
* 该类没有可访问的无参数构造方法
Serializable标记接口。该接口给需要序列化的类,提供了一个序列版本号。serialVersionUID. 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
~~~
//给类显示声明一个序列版本号。
private static final long serialVersionUID = 1L;
~~~
## 瞬态关键字transient
当一个类的对象需要被序列化时,某些属性不需要被序列化,这时不需要序列化的属性可以使用关键字transient修饰。只要被transient修饰了,序列化时这个属性就不会被序列化了。
同时静态修饰也不会被序列化,因为序列化是把对象数据进行持久化存储,而静态的属于类加载时的数据,不会被序列化。
~~~
private transient/*瞬态*/ int age;
~~~
# 例子
Info类
~~~
package com.study;
import scala.runtime.Int;
import java.io.Serializable;
class Info implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int price;
public Info(String name, int price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public void show() {
System.out.println("---show方法---");
System.out.println("price---" + this.price);
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("{");
sb.append("\"name\":\"")
.append(name).append('\"');
sb.append(",\"price\":")
.append(price);
sb.append('}');
return sb.toString();
}
}
~~~
HelloWorld类
~~~
package com.study;
import java.io.*;
public class HelloWorld {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//ser();
dser();
}
public static void ser() throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream(new File("/Users/jdxia/Desktop/study/jdxia/src/main/java/hello.txt"))
);
//序列化对象
oos.writeObject(new Info("java", 70));
oos.close();
}
public static void dser() throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream(new File("/Users/jdxia/Desktop/study/jdxia/src/main/java/hello.txt"))
);
//按照obj读取
Object obj = ois.readObject();
Info info = (Info) obj;
System.out.println(info);
info.show();
ois.close();
}
}
~~~