IO流（二）

2、对象流

java.io.ObjectOutputStream和java.io.ObjectInputSteam

• 对象流是一对高级流，在流连接中的作用是进行对象的序列化与反序列化。实现对象的持久存储。
• java.io.ObjectOutputStream
  对象序列化 (对象输出流)：将一个java对象按照其结构转换为一组字节的过程。
• java.io.ObjectInputSteam
  对象反序列化 (对象输入流)：将一组字节还原为java对象(前提是这组字节是一个对象序列化得到的字节，要与在序列化时创建的版本号一致)。

对象序列化的流连接操作原理图:

2.1 序列化（ObjectOutputStream）：

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。
需要进行序列化的类必须实现接口：java.io.Serializable
实现序列化接口后最好主动定义序列化版本号这个常量。
这样一来对象序列化时就不会根据类的结构生成一个版本号,而是使用该固定值。
那么反序列化时，只要还原的对象和当前类的版本号(serialVersionUID)一致就可以进行还原。

public static final long serialVersionUID = 1L;  //定义一个固定的版本号

注：

一个对象要想序列化，必须满足两个条件：
        该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出
java.io.NotSerializableException。
        该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

transient关键字：
关键字可以修饰属性，用于在进行对象序列化时忽略不必要的属性，达到对象瘦身的目的

• 构造方法：

public ObjectOutputStream(OutputStream out)：

                                                         创建一个指定OutputStream的ObjectOutputStream。

例：
        //文件输出流

        FileOutputStream fos=new FileOutputStream("stu.txt");

        //创建序列化流

        ObjectOutputStream oos=new ObjectOutputStream(fos);

• 序列化方法：

public final void writeObject (Object obj) :         将指定的对象写出。

• 序列化操作：

​
package demo;
import java.io.Serializable;
import java.util.Arrays;
/**
 * 使用当前类的实例测试对象流的序列化与反序列化操作
 */
public class Person implements Serializable {
    /*
    实现序列化接口后最好主动定义序列化保本号这个常量。
    这样一来对象序列化时就不会根据类的结构生成版本号，而是使用该固定值。
    那么反序列化时，只要还原的对象和当前类的版本号一致就可以进行还原。
     */
    public static final long serialVersionUID = 1L;//版本号
    private String name;
    private transient int age;
    private String gender;
    private String[] otherInfo;

    public Person(String name, int age, String gender, String[] otherInfo) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.otherInfo = otherInfo;
    }
    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 String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String[] getOtherInfo() {
        return otherInfo;
    }
    public void setOtherInfo(String[] otherInfo) {
        this.otherInfo = otherInfo;
    }

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + ", gender='" + gender + '\'' + ", otherInfo=" + Arrays.toString(otherInfo) + '}';
    }
}

​

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

/**
 * 对象序列化：将对象按照其结构转化为一组字节的过程
 */
public class Test {
    public static void main(String[] args) throws IOException {
        /*
            将一个Person对象写入文件
            1：先将Person对象转换为一组字节
            2：将字节写入文件
            流连接：
                    序列化     持久化
                      V         V
            对象---->对象流---->文件流---->文件
         */
        //将一个Person对象写入文件person.obj
        String name = "Kitty";
        int age = 18;
        String gender = "女";
        String[] otherInfo = {"我顶着大太小","只想为你撑伞"};
        Person p = new Person(name,age,gender,otherInfo);
        //创建序列化流对象
        FileOutputStream fos = new FileOutputStream("person.obj");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
         写出对象
        oos.writeObject(p);
        System.out.println("写出完毕!");
        //关闭流
        oos.close();
    }
}

2.2 反序列化（ObjectInputStream）： 

java.io.ObjectInputStream类是反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象（将一组字节还原为java对象），前提是这组字节是一个对象序列化得到的字节。

• 构造方法：

public ObjectInputStream(InputStream in)：

                                                                创建一个指定InputStream的ObjectInputStream。

例：

        //文件输出流
        FileInputStream fileIn = new FileInputStream("employee.txt");

        //创建反序列化流
        ObjectInputStream in = new ObjectInputStream(fileIn);

注：

当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。

常发生这个异常的原因如下：
        1、该类的序列版本号与从流中读取的类描述符的版本号不匹配
        2、该类包含未知数据类型
        2、该类没有可访问的无参数构造方法

• 序列化方法：

public final Object readObject () :         读取一个对象。

注：
该方法会进行对象的反序列化，如果对象流通过其连接的流读取的字节分析并非
是一个java对象时，会抛出异常:ClassNotFoundException

• 序列化操作：

package demo;
import io.Person;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
 * 使用对象输入流完成对象的反序列化
 */
public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //从person.obj文件中将对象反序列化回来
        FileInputStream fis = new FileInputStream("person.obj");
        ObjectInputStream ois = new ObjectInputStream(fis);
        /*
            Object readObject()
            该方法会进行对象的反序列化，如果对象流通过其连接的流读取的字节分析并非
            是一个java对象时，会抛出异常:ClassNotFoundException
         */
        Person p = (Person)ois.readObject();
        System.out.println(p);
    }
}

总结：

• 对象流

对象流是一对高级流，在流链接中的作用是完成对象的序列化与反序列化

序列化：是对象输出流的工作，将一个对象按照其结构转换为一组字节的过程。

反序列化：是对象输入流的工作，将一组字节还原为对象的过程。

java.io.ObjectInputStream对象输入流，继承自java.io.InputStream

常用构造器

ObjectInputStream(InputStream in)：创建一个对象输入流并连接到参数in这个输入流上。

常用方法

Object readObject()：进行对象反序列化，将读取的字节转换为一个对象并以Object形式返回(多态)。

如果读取的字节表示的不是一个java对象会抛出异常:java.io.ClassNotFoundException

java.io.ObjectOutputStream对象输出流，继承自java.io.OutputStream

常用构造器

ObjectOutputStream(OutputStream out)：创建一个对象输出流并连接到参数out这个输出流上

常用方法

void writeObject(Object obj)：进行对象的序列化，将一个java对象序列化成一组字节后再通过连接的输出流将这组字节写出。

如果序列化的对象没有实现可序列化接口:java.io.Serializable就会抛出异常:java.io.Not
SerializableException

序列化接口java.io.Serrializable

该接口没有任何抽象方法，但是只有实现了该接口的类的实例才能进行序列化与反序列化。

实现了序列化接口的类建议显示的定义常量:static final long serialVersionUID = 1L;

可以为属性添加关键字transient，被该关键字修饰的属性在序列化是会被忽略，达到对象序列化瘦身的目的。

 对象流结束！下一环节 >>>【 字符流 】<<<