对象流ObjectInputStream类【反序列化】和ObjectOutputStream类【序列化】

最新推荐文章于 2024-05-07 20:52:33 发布

昱晟168

最新推荐文章于 2024-05-07 20:52:33 发布

阅读量942

点赞数 1

分类专栏： IO流文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_47267628/article/details/123339792

版权

IO流专栏收录该内容

11 篇文章 0 订阅

订阅专栏

对象流`ObjectInputStream`和`ObjectOutputStream`

看一个需求：

1.将int num = 100 这个int数据保存到文件中，注意不是100数字，而是 int 100，并且，能够从文件中直接恢复 int 100
2.将 Dog dog = new Dog("小黄"，3);这个 dog对象保存到文件中，并且能够从文件中恢复
3.上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化操作

序列化和反序列化

序列化就是在保存数据时，保存数据的值和数据类型
反序列化就是在恢复数据时，恢复数据的值和数据类型
需要让某个对象支持序列化机制，则必须让基类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：

Serializable：这是一个标记接口，没有方法

Externalizable：该接口有方法需要实现，因此我们一般实现上面的 Serializable接口

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qnWAlZmc-1646658281083)(E:\Typora笔记\java笔记\img\image-20220306164032599.png)]$

序列化和反序列化的解释：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sJyTHXlS-1646658281085)(E:\Typora笔记\java笔记\img\image-20220306164116937.png)]$

对象流介绍：

功能：提供了对基本类型或对象的序列化和反序列化的方法

ObjectOutputStream：提供了序列化功能

ObjectInputStream：提供了反序列化功能

`ObjectInputStream`类：用于反序列化

继承关系图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z0YuHXrz-1646658281086)(E:\Typora笔记\java笔记\img\image-20220306164432710.png)]$

`ObjectOutputStream`类：用于序列化

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sfN8gFUX-1646658281086)(E:\Typora笔记\java笔记\img\image-20220306165348401.png)]$

应用案例：

使用ObjectOutputStream 序列化 基本数据类型和一个Dog对象【name,age】，并且保存到 data.dat 文件中 ObjectOutputStream

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bc6hyW2F-1646658281087)(E:\Typora笔记\java笔记\img\image-20220306170614592.png)]$

package IO_.ObjectStream_;

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

/**
 * @author: 海康
 * @version: 1.0
 */
public class ObjectOutputStream1 {
    public static void main(String[] args) throws Exception {
        String writerPath = "E:\\IDEACODE\\javase\\date.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(writerPath, true));
        // 写入 100 会自动装箱成 Integer （Integer是实现了 Serializable）的
        oos.write(100);
        // 'E' 会自动装箱成 Character （Character是实现了 Serialization）的
        oos.writeChar('E');
        // 1.68 会自动装箱成 Double （Double是实现了 Serialization）的
        oos.writeDouble(1.68);

        // "海康” （String 是实现了 Serialization）的
        oos.writeUTF("海康");

        // 写入 Dog 类 必须要实现 Serialization 接口，不然会报错
        // 必须要实现 Serialization 否则报错
        oos.writeObject(new Dog("吴*凡",32));
    }
}


package IO_.ObjectStream_;

import java.io.Serializable;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Dog implements Serializable {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "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;
    }
}


package IO_.ObjectStream_;


import java.io.FileInputStream;
import java.io.IOException;

/**
 * @author: 海康
 * @version: 1.0
 */
public class ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String readPath = "E:\\IDEACODE\\javase\\date.dat";
        java.io.ObjectInputStream ois = new java.io.ObjectInputStream(new FileInputStream(readPath));

        // 对date.dat文件进行反序列化
        // 注意是：在反序列化时一定要遵守序列化的顺序
        System.out.println(ois.readInt());
        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());

        // 在反序列化对象时，一定要能够引入该类的引用
        System.out.println(ois.readObject());
        Object object = ois.readObject();
        Dog dog = (Dog) object;
        System.out.println("姓名=："+dog.getName());

        // 在使用完成后，一定要关闭流，释放资源
        ois.close();
        System.out.println("反序列化完成！！！");
    }
}

package com.hspedu.outputstream_;

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

/**
 * 演示ObjectOutputStream的使用, 完成数据的序列化
 */
public class ObjectOutStream_ {
    public static void main(String[] args) throws Exception {
        //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
        String filePath = "e:\\data.dat";

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        //序列化数据到 e:\data.dat
        oos.writeInt(100);// int -> Integer (实现了 Serializable)
        oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
        oos.writeChar('a');// char -> Character (实现了 Serializable)
        oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
        oos.writeUTF("湛江");//String
        //保存一个dog对象
        oos.writeObject(new Dog("旺财", 10, "日本", "白色"));
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");


    }
}



package com.hspedu.outputstream_;

import java.io.Serializable;


//如果需要序列化某个类的对象，实现 Serializable
public class Dog implements Serializable {
    private String name;
    private int age;
    //序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
    private static String nation;
    private transient String color;
    //序列化对象时，要求里面属性的类型也需要实现序列化接口
    private Master master = new Master();

    //serialVersionUID 序列化的版本号，可以提高兼容性
    private static final long serialVersionUID = 1L;

    public Dog(String name, int age, String nation, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.nation = nation;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}' + nation + " " +master;
    }

    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;
    }
}


package com.hspedu.inputstream_;



import com.hspedu.outputstream_.Dog;

import java.io.*;


public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //指定反序列化的文件
        String filePath = "e:\\data.dat";

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));

        //读取
        //老师解读
        //1. 读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致
        //2. 否则会出现异常

        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());

        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());


        //dog 的编译类型是 Object , dog 的运行类型是 Dog
        Object dog = ois.readObject();
        System.out.println("运行类型=" + dog.getClass());
        System.out.println("dog信息=" + dog);//底层 Object -> Dog

        //这里是特别重要的细节:

        //1. 如果我们希望调用Dog的方法, 需要向下转型
        //2. 需要我们将Dog类的定义，放在到可以引用的位置
        Dog dog2 = (Dog)dog;
        System.out.println(dog2.getName()); //旺财..

        //关闭流, 关闭外层流即可，底层会关闭 FileInputStream 流
        ois.close();


    }
}

注意是：一般在实现了序列化的类添加一个 //serialVersionUID 序列化的版本号，可以提高兼容性 private static final long serialVersionUID = 1L;属性，提高版本的兼容性

使用序列化和反序列化注意事项和细节说明

读写顺序要一致
要求序列化或反序列化对象，需要实现Serializable接口
序列化的类中建议添加SerialVersionUID，为了提高版本的兼容性
序列化对象时，默认将里面所有属性都进行序列化，但是除了static或transient修饰的成员
序列化对象时，要求里面所有属性的类型也需要实现序列化接口
序列化具备可继承性，也就是如果某个类已经实现了序列化，则它的所有子类也已经默认实现了序列化

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3SSxX5DJ-1646658281087)(E:\Typora笔记\java笔记\img\image-20220306192629954.png)]$

代码演示：

package IO_.ObjectStream_;

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

/**
 * @author: 海康
 * @version: 1.0
 */
public class ObjectOutputStream1 {
    public static void main(String[] args) throws Exception {
        String writerPath = "E:\\IDEACODE\\javase\\date.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(writerPath));
        // 写入 100 会自动装箱成 Integer （Integer是实现了 Serializable）的
        oos.writeInt(100);// 注意是在序列化一定要带上数据类型的后缀
        // 'E' 会自动装箱成 Character （Character是实现了 Serialization）的
        oos.writeChar('E');
        // 1.68 会自动装箱成 Double （Double是实现了 Serialization）的
        oos.writeDouble(1.68);

        // "海康” （String 是实现了 Serialization）的
        oos.writeUTF("海康");

        // 写入 Dog 类 必须要实现 Serialization 接口，不然会报错
        // 必须要实现 Serialization 否则报错
        oos.writeObject(new Dog("吴*凡",32));

        // 在使用完毕后一定要关闭流，释放资源
        oos.close();

        System.out.println("序列化完成！！！");
    }
}


package IO_.ObjectStream_;

import java.io.Serializable;

/**
 * @author: 海康
 * @version: 1.0
 */
// 2.要求序列化或反序列化对象【就是该类】必须要实现Serializable接口
public class Dog implements Serializable {
    private String name;
    private int age;
    private static  char sex; // 这个属性是不被序列化
    transient  String color ;//这个属性是不被序列化的
    private Master master = new Master();// 该属性必须进行序列化，否则运行时会报错
    private static final long SerialVersionUID = 1l;// 为了匹配兼容性

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                ", master=" + master +
                '}';
    }

    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;
    }
}

class Master implements Serializable{}


package IO_.ObjectStream_;


import java.io.FileInputStream;
import java.io.IOException;

/**
 * @author: 海康
 * @version: 1.0
 */
public class ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String readPath = "E:\\IDEACODE\\javase\\date.dat";
        java.io.ObjectInputStream ois = new java.io.ObjectInputStream(new FileInputStream(readPath));

        // 对date.dat文件进行反序列化
        // 注意是：在反序列化时一定要遵守序列化的顺序
        System.out.println(ois.readInt());
        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());

        // 在反序列化对象时，一定要能够引入该类的引用
        System.out.println(ois.readObject());
        Object object = ois.readObject();
        Dog dog = (Dog) object;
        System.out.println("姓名=："+dog.getName());

        // 在使用完成后，一定要关闭流，释放资源
        ois.close();
        System.out.println("反序列化完成！！！");
    }
}

昱晟168

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
对象流ObjectInputStream类【反序列化】和ObjectOutputStream类【序列化】

对象流ObjectInputStream和ObjectOutputStream看一个需求：1.将int num = 100 这个int数据保存到文件中，注意不是100数字，而是 int 100，并且，能够从文件中直接恢复 int 1002.将 Dog dog = new Dog("小黄"，3);这个 dog对象保存到文件中，并且能够从文件中恢复3.上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化操作序列化和反序列化序列化就是在保存数据时，保存数据的值和数据类型反序列化就
复制链接

扫一扫