【java:ObjectOutputStream对象输出流】对象序列化和反序列化

要求：

学生类：

包含私有属性 id, name,address, age;

age属性用transient修饰，不需要被序列化；

测试类1：

序列化：传入参数：1，Jack，北京，18；

利用ObjectOutputStream，把该对象序列化，写进文件，命名为：student.txt；

测试类2：

反序列化：利用 ObjectInputStream ,把序列化后得到的student.txt文件的内容反序列化，读取出来，在控制台打印输出。

Student.java学生类：

package mypackage;

import java.io.Serializable;

public class Student implements Serializable {
    //属性
    private int id;
    private String name;
    private String address;
    private transient int age;//transient瞬态属性不需要被序列化

    //无参构造方法
    public Student() {
    }
    //含全部参数构造方法

    public Student(int id, String name, String address, int age) {
        this.id = id;
        this.name = name;
        this.address = address;
        this.age = age;
    }
    //右键generate，快速构建get/set方法

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Test99.java测试类:

package mypackage;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Test99 implements Serializable {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setId(1);
        stu.setName("Jack");
        stu.setAddress("北京");
        stu.setAge(18);
        ObjectOutputStream out = null;
        //创建序列化流对象
        //FileOutputStream下方有红线，选择提示，try...catch
        try {
            out = new ObjectOutputStream(new FileOutputStream("Student.txt"));
            out.writeObject(stu);
            System.out.println("该对象已经被序列化了");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Test100.java测试类：

package mypackage;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;

public class Test100 implements Serializable {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        Student stu = null;

        try {
            ois = new ObjectInputStream(new FileInputStream("Student.txt"));
            stu = (Student)ois.readObject();
        } catch (IOException var14) {
            var14.printStackTrace();
        } catch (ClassNotFoundException var15) {
            var15.printStackTrace();
        } finally {
            try {
                ois.close();
            } catch (IOException var13) {
                var13.printStackTrace();
            }
        }
        System.out.println("id:" + stu.getId());
        System.out.println("name:" + stu.getName());
        System.out.println("address:" + stu.getAddress());
        System.out.println("age:" + stu.getAge());
    }
}

运行结果：

Test99.java，进行序列化后：（这是对象序列化以后，文件的内容，不知道可不可以显示成正常的文字，有知道的小伙伴吗？）

 Test100.java,进行反序列化后：

总结：

序列化：对象序列化的机制，用一个字节序列可以表示一个对象，将对象写入文件，相当于在文件中持久保存。

反之，该字节序列还可以从文件中读取出来，重构对象，对它进行反序列化。

ObjectInputStream    序列化      对象转换为字节

ObjectOutputStream 反序列化   字节重构为对象

作用：将java对象的数据写出到文件，实现对象的持久存储

注意：age属性用transient修饰，不需要被序列化，所以文件里面是没有age这个属性的信息的。