java IO流 - 序列化流

序列化流在IO流体系中的位置

ObjectOutputStream：对象字节输出流（序列化流）

• ObjectOutputStream将 Java 对象和原始数据类型序列化为字节流，写入 OutputStream。

ObjectOutputStream的构造器：

• public ObjectOutputStream(OutputStream out)：创建一个写入指定输出流的对象输出流。

ObjectOutputStream的方法：

• public final void writeObject(Object obj)：将指定对象写入对象输出流（ObjectOutputStream）。

注意：对象如果要被序列化，必须实现序列化接口java.io.Serializable。

示例：用ObjectOutputStream序列化一个对象

定义一个Student类：

package com.team;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;
    private double score;

    public Student() {
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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 double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

定义一个测试类，进行序列化的工作：

package com.team;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class Test {

    public static void main(String[] args) {
        try (
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.txt"));
                ) {
            Student s = new Student("张三", 22, 99);
            oos.writeObject(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行，生成了文件：

ObjectInputStream：对象字节输入流（反序列化流）

• ObjectInputStream 用于反序列化先前使用 ObjectOutputStream 写入的原始数据和对象。

ObjectInputStream的构造器：

• public ObjectInputStream(InputStream in)：创建一个从指定 InputStream 读取的ObjectInputStream。

ObjectInputStream的方法：

• public final Object readObject()：从 ObjectInputStream 读取一个对象。

示例：用ObjectInputStream反序列化一个对象

Student类：

package com.team;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;
    private double score;

    public Student() {
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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 double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

out.txt 文件是上个示例中用ObjectOutputStream序列化出去的，现在要反序列化：

package com.team;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class Test2 {

    public static void main(String[] args) {
        try (
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("out.txt"));
                ) {
            Student s = (Student) ois.readObject();
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行输出：

Student{name='张三', age=22, score=99.0}

用transient修饰的成员变量不参与序列化

下面的Student 类中，成员变量score用transient 修饰，所以不会参与序列化：

package com.team;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;
    // 加了transient修饰符，这个成员变量不参与序列化
    private transient double score;

    public Student() {
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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 double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

序列化代码：

package com.team;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class Test {

    public static void main(String[] args) {
        try (
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.txt"));
                ) {
            Student s = new Student("张三", 22, 99);
            oos.writeObject(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行。

下面反序列化：

package com.team;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class Test2 {

    public static void main(String[] args) {
        try (
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("out.txt"));
                ) {
            Student s = (Student) ois.readObject();
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行输出：

Student{name='张三', age=22, score=0.0}

从输出可以看到，score确实没有参与序列化。

示例：一次序列化多个对象

如果要一次序列化多个对象，可以创建一个ArrayList集合，在集合中保存多个对象，然后对ArrayList进行序列化、反序列化，因为ArrayList集合实现了序列化接口Serializable：

Student类：

package com.team;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;
    private double score;

    public Student() {
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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 double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

序列化代码：

package com.team;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        try (
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.txt"));
                ) {
            List<Student> students = new ArrayList<>();
            students.add(new Student("张三", 22, 90));
            students.add(new Student("李四", 32, 60));
            students.add(new Student("王五", 19, 70));

            oos.writeObject(students);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行，生成了out.txt文件：

下面是反序列化代码：

package com.team;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;

public class Test2 {

    public static void main(String[] args) {
        try (
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("out.txt"));
                ) {
            List<Student> students = (ArrayList) ois.readObject();
            System.out.println(students);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行输出：

[Student{name='张三', age=22, score=90.0}, Student{name='李四', age=32, score=60.0}, Student{name='王五', age=19, score=70.0}]