ObjectInputStream 和 ObjectOutStream流

最新推荐文章于 2024-03-01 00:40:54 发布
最新推荐文章于 2024-03-01 00:40:54 发布
阅读量2.7k 收藏 46
点赞数 9
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43808717/article/details/115119952
版权

1. 简介

对象流：ObjectInputStream 和 ObjectOutStream，DataInputStream/DataOutputStream流只是解决了Java8种基础数据类型的流，而对象流不仅仅有读写Java的8种基础数据类型还可以将一个实例化的对象写入磁盘。

  1. 序列化：将一个实例化对象写入磁盘叫做序列化。

  2. 反序列化：将一个写入磁盘的的实例化读取出来转化为一个对象叫做反序列化。

  3. 需要序列化的对象类一定要实现Serializable接口。


2. 序列化(ObjectOutputStream)

  1. ObjectOutputStream流是一个字节流，所以它是基于字节的。构造方法里面需要传入一个OutputStream对象。

  2. ObjectOutputStream流和DataOutputStream流一样，写入文件的数据会出现乱码的情况。

  3. 需要实例化的类一定要实现Serializable接口。

import java.io.*;
/*
    ObjectOutputStream实现对象的序列化
    需要序列化的对象类一定要实现Serializable接口
 */
class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.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;
    }

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

public class Demo01 {
    public static void main(String[] args) {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student zhangsan = new Student("zhangsan",22);
            oos.writeObject(zhangsan);
            oos.flush();
            System.out.println("序列化完成!");
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述


3. 反序列化(ObjectInputStream流)

import java.io.*;
class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.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;
    }

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

public class Demo01 {
    public static void main(String[] args) {
        try{
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student zhangsan = new Student("zhangsan",22);
            oos.writeObject(zhangsan);
            System.out.println("序列化完成!");

            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student s = (Student) ois.readObject();

            ois.close();
            System.out.println(s.toString());
            System.out.println("反序列化完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

在这里插入图片描述

4. 序列化和反序列化注意事项

  1. 序列化的类一定要实现Serializable接口。

  2. 序列化类中的对象属性也要求实现Serializable接口。

import java.io.*;
class Person{

}
class Student implements Serializable {
    private String name;
    private int age;
    private Person person;
    public Student(String name, int age,Person person) {
        this.name = name;
        this.age = age;
        this.person = person;
    }

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

public class Demo01 {
    public static void main(String[] args) {
        try{
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student zhangsan = new Student("zhangsan",22,new Person());
            oos.writeObject(zhangsan);
            System.out.println("序列化完成!");

            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student s = (Student) ois.readObject();

            ois.close();
            System.out.println(s.toString());
            System.out.println("反序列化完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

在这里插入图片描述


  1. serialVersionUID是序列化版本号ID，用来保证序列化的类和反序列化的类是同一个。如果反序列化和序列化写入的ID不匹配那么会报出异常。
import java.io.*;
class Student implements Serializable {

    private static final long serialVersionUID = 50L;
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

public class Demo01 {
    public static void main(String[] args) {
        try{

            //最开始已经写入一个没有设置serialVersionUID的 Student{name='zhangsan', age=22}
            //然后我们设置serialVersionUID = 50L   再去反序列化
            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student s = (Student) ois.readObject();

            ois.close();
            System.out.println(s.toString());
            System.out.println("反序列化完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

在这里插入图片描述


  1. transient修饰的属性 和 static修饰的属性无法被序列化。
import java.io.*;

class Student3 implements Serializable {

    private static final long serialVersionUID = 50L;
    private String name;
    private int age;
    private transient int id;
    private static String classname = "一班";
    public Student3(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    @Override
    public String toString() {
        return "Student3{" + "name='" + name + '\'' + ", age=" + age + ", id=" + id + '}';
    }
}
public class Demo03 {
    public static void main(String[] args) {
        try{
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student3 zhangsan = new Student3("zhangsan",22,1);
            oos.writeObject(zhangsan);
            System.out.println("序列化完成!");

            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student3 s = (Student3) ois.readObject();

            ois.close();
            System.out.println(s.toString());
            System.out.println("反序列化完成!");
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

  1. 序列化多个对象可以使用一些实现了Serializable接口的集合类来完成。比如ArrayList类。
import java.io.*;
import java.util.ArrayList;

class Student4 implements Serializable {

    private static final long serialVersionUID = 50L;
    private String name;
    private int age;
    public Student4(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student4{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}
public class Demo04 {
    public static void main(String[] args) {
        try{
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student4 zhangsan = new Student4("zhangsan",22);
            Student4 lisi = new Student4("lisi",21);


            ArrayList<Student4> list = new ArrayList<>();
            list.add(zhangsan);
            list.add(lisi);

            oos.writeObject(list);
            System.out.println("序列化完成!");

            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            list = (ArrayList<Student4>)ois.readObject();
            System.out.println(list.toString());
            System.out.println("反序列化完成!");
            ois.close();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

在这里插入图片描述



Splaying
关注
  • 9
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
（七）java.io.ObjectInputStream类详解
OceanSky的专栏
02-22 1万+
1.public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants 分析：ObjectInputStream是将对象的原始数据序列化，ObjectOutputStream将序列化的数据反序列化。当分别使用FileInputStream和FileOutStream做为输...
java学习笔记63：对象输入输出流
八十岁老将的博客
01-22 557
1、ObjectInputStream(对象输入流) 1.1 构造方法 protected ObjectInputStream() //为完全重新实现ObjectInputStream的子类提供一种方法，以便不必分配此ObjectInputStream实现刚刚使用的私有数据。 ObjectInputStream​(InputStream in) //创建一个从指定的InputStream读取的ObjectInputStream。 1.2 方法 int available() //返回可以不阻塞地
(每日持续更新）jdk api之ObjectInputStream基础、应用、实战
a89879193的专栏
02-09 1048
用于读取序列化对象的字段值的GetField对象。从流中读取默认的对象字段值，以恢复对象的状态。读取序列化对象的字段值，返回一个GetField对象，可以用于访问字段的值。int read()从输入流中读取一个字节的数据。从输入流中读取对象。从输入流中读取字节数组的一部分数据。从输入流中读取一个未共享的对象。注册一个对象验证回调。
【Java I/O 流】对象流：ObjectInputStream 和 ObjectOutputStream
水滴的博客
08-16 2212
对象流有两个类：ObjectOutputStream 和 ObjectInputStream，其主要作用是将 Java 对象序列化为流数据，或将流数据反序列化为 Java 对象。
【IO流系列】ObjectStream 序列化流与反序列化流
最新发布
kuxiaoyang的博客
03-01 1194
Java 提供了一种对象**序列化**的机制。用一个字节序列可以表示一个对象，该字节序列包含该`对象的数据`、`对象的类型`和`对象中存储的属性`等信息。字节序列写出到文件之后，相当于文件中**持久保存**了一个对象的信息。 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行**反序列化**。`对象的数据`、`对象的类型`和`对象中存储的数据`信息，都可以用来在内存中创建对象。
ObjectInputStream 和 ObjectOutputStream 介绍_动力节点Java学院整理
08-30
在 Java 中，`ObjectInputStream` 和 `ObjectOutputStream` 是两个非常重要的类，它们分别用于实现对象的反序列化和序列化。序列化是将对象的状态转换为字节流的过程，以便可以存储在磁盘上或通过网络传输。反序列化...
java序列化与ObjectOutputStream和ObjectInputStream的实例详解
08-29
Java序列化与ObjectOutputStream和ObjectInputStream的实例详解 Java序列化是指将Java对象转换为字节流的过程，以便将其存储或传输，而后可以将其恢复为原来的对象状态。Java提供了两种方式来实现序列化： ...
IOstream_javaIOl流_
10-02
- 对象序列化：ObjectInputStream和ObjectOutputStream允许将Java对象转换为字节流进行持久化存储或网络传输。 - 数据操作：DataInputStream和DataOutputStream提供方法读写基本数据类型，如int、float等。 - 复用流...
输入输出流和文件操作
01-10
1. **文件和流的概念**： - **文件**：在操作系统中，文件是存储信息的基本单元，它包含一组有序的数据。文件系统管理文件的创建、删除、读取和写入。 - **目录结构与文件检索**：目录（或称文件夹）组织文件，...
OtherStreamTest_数据流_
10-03
在Java中，`ObjectInputStream`和`ObjectOutputStream`类用于对象流的序列化和反序列化。序列化是将对象转换为字节流的过程，便于存储或网络传输；反序列化则是将字节流恢复为对象。 8. **OtherStreamTest.java**...
Java IO系列2 InputStream之ObjectInputStream
L25000的专栏
12-23 3043
一、对象序列化 当一个可序列化类有多个父类时（包括直接父类和间接父类），这些父类要么有无参数的构造器，要么也是可序列化的，否则反序列化时抛出InvalidClassException。如果父类是不可序列化的，只是带有无参数的构造器，则该父类中定义的Field值不会序列化到二进制流中 public class Computer { public String name; public in
2022d3CTF 部分web题基础知识学习
weixin_51458899的博客
03-23 4108
[d3ctf2020]shorter rome1.0反序列化链调试见上面（第三周标题为[d3ctf2020]的内容） 当时参考的资料： ROME反序列化分析 (c014.cn) javassist使用全解析 - rickiyang - 博客园 (cnblogs.com) https://xz.aliyun.com/t/6787#toc-8 (java反射入门) https://developer.huawei.com/consumer/cn/forum/topic/020447303398723010
对象反序列化流:ObjectInputStream
o676448的博客
04-10 755
对象返序列化流 对象反序列化流:ObjectInputStream 构造方法: ObjectInputStream(InputStream in); 创建从指定的InputStream读取的ObjectInputStream 反序列化对象的方法: Object readObject(); 从ObjectInputStream读取一个对象
Java中的IO流（ObjectInputStream）
张子又
12-29 646
ObjectInputStream: ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。 只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。 注意：如果一个类被序列化之后，改动了这个类的属性或者方法之类，反序列化的时候，会报错（序列化版本异常） 如何解决...
ObjectOutputStream/ObjectInputStream多个类输入输出总结
qq_62845325的博客
11-26 757
ObjectOutputStream/ObjectInputStream多个类输入输出总结
JAVA 中级- JAVA 对象流 OBJECTINPUTSTREAM,OBJECTOUTPUTSTREAM
q306507291的博客
07-16 287
1.JAVA 对象流 Java IO 对象流 对象流指的是可以直接把一个对象以流的形式传输给其他的介质，比如硬盘。 一个对象以流的形式进行传输，叫做序列化。 该对象所对应的类，必须是实现Serializable接口。 [疯狂Java]I/O：I/O流的最高境界——对象流（序列化：手动序列化、自动序列化、引用序列化、版本） 1. 什么是对象流：序列化/反序列化的概念 1) 对象流是和字节流/字符流同处于一个概念体系的： ...
ObjectStream对象流&Properties类常用方法&Thread线程的创建方式和线程常用api
Menfolk_k的博客
07-29 271
对象流 序列化: Serialiaze 将java对象转换为二进制流ObjectOutputStream .writeObject(java对象) 反序列化: 二进制流还原java对象ObjectInputStream .readObject() --> java对象 java中要支持序列化和反序列化,需要实现接口Serializable(标记接口) seriaVersionUID序列化版本(序列号) 当对class类做修改时,seriaVersionUID就会变动,反序列化时就会报异常,可以把
Java中ObjectOutputStream和ObjectInputStream的基本使用详解
热门推荐
刘先森
10-05 1万+
在我们讲解对象输出流和对象输入流之前，我们首先要明确两个概念： - 序列化和反序列化： - 将一个特定的数据结构转换为一组字节的过程称之为序列化 - 将一组字节转换为特定的数据结构的过程称之为反序列化 - 持久化： - 将数据写入硬盘长久保存的过程称之为持久化 ObjectOutputStream的使用 ObjectOutputStream是一个高级流， 将 Jav
java readobject_java objectinputstream中的readObject如何知道要读取多少字节？
weixin_39963174的博客
02-21 188
readOject()方法正在使用BlockedInputStream读取字节。如果检查ObjectInputStream的readObject，它正在调用readObject0(false).private Object readObject0(boolean unshared) throws IOException {boolean oldMode = bin.getBlockDataMode...
objectinputstream是什么流
09-13
ObjectInputStream是Java中的一个输入流，它可以将Java对象序列化后的字节流反序列化成Java对象。它可以读取Java对象的属性和状态，并将其还原成原始的Java对象。ObjectInputStream通常与ObjectOutputStream一起使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值