序列化流和反序列化流、 Serializable 接口、 transient瞬态关键字

最新推荐文章于 2025-12-10 10:39:47 发布

原创最新推荐文章于 2025-12-10 10:39:47 发布 · 204 阅读

0 ·

CC 4.0 BY-SA版权

Java_基础专栏收录该内容

29 篇文章

订阅专栏

1.什么是序列化流什么是反序列化流？

在这里插入图片描述

2.OutputStream（把对象写进硬盘）

java.io.ObjectOutputStream extends OutputStream
ObjectOutputStream:对象的序列化流
作用:把对象以流的方式写入到文件中保存

构造方法:
    ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。
    参数:
        OutputStream out:字节输出流
特有的成员方法:
    void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

使用步骤:
1.创建ObjectOutputStream对象,构造方法中传递字节输出流
2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
3.释放资源

序列化和反序列化的时候,会抛出NotSerializableException没有序列化异常
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
Serializable接口也叫标记型接口（里面没有抽象方法）
要进行序列化和反序列化的类必须实现Serializable接口（就是下面代码的Person类必须实现Serializable接口）,就会给类添加一个标记
当我们进行序列化和反序列化的时候,就会检测类上是否有这个标记
有:就可以序列化和反序列化
没有:就会抛出 NotSerializableException异常
去市场买肉–>肉上有一个蓝色章(检测合格)–>放心购买–>买回来怎么吃随意

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

/**
 * @author QLBF
 * @version 1.0
 * @date 2020/11/15 17:01
 */
class Person implements Serializable{
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }
    public Person() {
    }
}
public class xulietest {
    public static void main(String[] args) throws Exception {
        //1.创建ObjectOutputStream对象,构造方法中传递字节输出流
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./day_19/person.txt"));
        //2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
        oos.writeObject(new Person("李白",25));
        //3.释放资源
        oos.close();
    }
}

最终生成person.txt，但它是乱码的（用记事本打开也乱码（因为它是以二进制存的）），得用反序列流。在这里插入图片描述

3.ObjectInputStream (把硬盘的对象文件读到内存（java程序）来)

java.io.ObjectInputStream extends InputStream
ObjectInputStream:对象的反序列化流
作用:把文件中保存的对象,以流的方式读取出来使用

构造方法:
ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。
参数:
InputStream in:字节输入流
特有的成员方法:
Object readObject() 从 ObjectInputStream 读取对象。

使用步骤:
1.创建ObjectInputStream对象,构造方法中传递字节输入流
2.使用ObjectInputStream对象中的方法readObject读取保存对象的文件
3.释放资源
4.使用读取出来的对象(打印)

readObject方法声明抛出了ClassNotFoundException(class文件找不到异常)
当不存在对象的class文件时抛出此异常
反序列化的前提:
1.类必须实现Serializable
2.必须存在类对应的class文件（就是你如果修改了Person类（改完就生成了class文件）但是没运行，那class变了，但你原本的.txt没变，那么这是你直接反序列化就找不到对应的class文件，就爆出异常）（可见下面第5点）

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

/**
 * @author QLBF
 * @version 1.0
 * @date 2020/11/15 17:32
 */
public class du {
    public static void main(String[] args) throws Exception {
        //1.创建ObjectInputStream对象,构造方法中传递字节输入流
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("day_19/person.txt"));
        //2.使用ObjectInputStream对象中的方法readObject读取保存对象的文件
        Object o = ois.readObject();
        //3.释放资源
        ois.close();
        //4.使用读取出来的对象(打印)
        System.out.println(o);//Person{name='李白', age=25}


        //向下转型
        Person p=(Person)o;
        System.out.println(p.getName()+":"+p.getAge());//李白:25

    }
}

4.static和transient区别（也差不多）

把上面代码的Person类改下，再执行一次序列化和反序列化
static关键字:静态关键字
静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
被static修饰的成员变量不能被序列化的,序列化的都是对象
private static int age;
oos.writeObject(new Person(“小美女”,18));
Object o = ois.readObject();
Person{name=‘小美女’, age=0}

transient关键字:瞬态关键字（跟static差不多，但它没static的含义）
被transient修饰成员变量,不能被序列化
private transient int age;
oos.writeObject(new Person(“小美女”,18));
Object o = ois.readObject();
Person{name=‘小美女’, age=0}