Java学习笔记③④（概述、ObjectOutputStream类、ObjectInputStream类、transient关键字、InvalidClassException异常、练习：序列化集合）

最新推荐文章于 2022-04-08 20:51:00 发布
最新推荐文章于 2022-04-08 20:51:00 发布
阅读量138 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45994391/article/details/118958745
版权

一、序列化

1.概述
在这里插入图片描述
在这里插入图片描述
2.ObjectOutputStream类
在这里插入图片描述

Preson类：

package Day01.demo04;

import java.io.Serializable;

/*
    序列化和反序列化的时候，会抛出NotSerializableException没有序列化异常
    类通过实现 Java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使用其任何状态的序列化或反序列
    Serialization接口也叫标记型接口
        要进行序列化和反序列化的类必须实现Serializable接口，就会给类添加一个标记
        当我们进行序列化和反序列化的时候，就会检测类上是否有这个标记
            有：就可以序列化和反序列化
            没有：就会抛出NotSerializableException异常
    去市场卖肉-->肉上有一个蓝色章（检测合格）-->放心购买-->买回来怎么吃随意
 */
public class Person implements Serializable {
    private String name;
    private int age;

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

    public Person() {
    }

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

}

主方法：

package Day01.demo04;

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

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

    构造方法：
        ObjectOutputStream(OutputStream out) 创建写入指定outputStream的ObjectOutputStream。
        参数：
            OutputStream out:字节输出流

    特有的成员方法：
        void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。

    使用步骤：
        1、创建ObjectOutputStream对象，构造方法中传递字节输出流
        2、使用ObjectOutputStream中的方法writeObject，把对象写入到文件中
        3、释放资源
 */
public class Demo04ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建ObjectOutputStream对象，构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
        //2.使用ObjectOutputStream对象中的方法writeObject，把对象写入到文件中。
        oos.writeObject(new Person("美好",19));
        //3.释放资源
        oos.close();

    }
}

运行结果：
以二进制形式展现
在这里插入图片描述

3.ObjectInputStream类
在这里插入图片描述
Person类：

package Day01.demo04;

import java.io.Serializable;

/*
    序列化和反序列化的时候，会抛出NotSerializableException没有序列化异常
    类通过实现 Java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使用其任何状态的序列化或反序列
    Serialization接口也叫标记型接口
        要进行序列化和反序列化的类必须实现Serializable接口，就会给类添加一个标记
        当我们进行序列化和反序列化的时候，就会检测类上是否有这个标记
            有：就可以序列化和反序列化
            没有：就会抛出NotSerializableException异常
    去市场卖肉-->肉上有一个蓝色章（检测合格）-->放心购买-->买回来怎么吃随意
 */
public class Person implements Serializable {
    private String name;
    private int age;

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

    public Person() {
    }

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

}

主方法：

package Day01.demo04;

import java.io.*;

/*
    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文件
 */
public class Demo04ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1、创建ObjectInputStream对象，构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
        //2、使用ObjectInputStream对象中的方法readObject读取保存对象的文件
        Object o = ois.readObject();
        //3、释放资源
        ois.close();
        //4、使用读取出来的对象（打印）
        System.out.println(o);
        Person p = (Person)o;
        System.out.println(p.getName()+p.getAge());
    }
}

运行结果：
在这里插入图片描述
4.transient关键字

Person类：

package Day01.demo04;

import java.io.Serializable;

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

    static关键字：静态关键字
        静态优先于非静态加载到内存中（静态优先于对象进入到内存中）
        被static修饰的成员变量不能被序列化的，序列化的都是对象
        private static int age
        oos.writeObject(new Person("美好",19));
        Object o = ois.readObject();
        Person{name="美好",age=0}
    transient关键字：瞬态关键字
        被transient关键字修饰成员变量，不能被序列化。
        private transient int age
        oos.writeObject(new Person("美好",19));
        Object o = ois.readObject();
        Person{name="美好",age=0}
 */
public class Person implements Serializable {
    private String name;
    //private static int age;
    private transient int age;

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

    public Person() {
    }

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

}

序列化主方法：

package Day01.demo04;

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

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

    构造方法：
        ObjectOutputStream(OutputStream out) 创建写入指定outputStream的ObjectOutputStream。
        参数：
            OutputStream out:字节输出流

    特有的成员方法：
        void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。

    使用步骤：
        1、创建ObjectOutputStream对象，构造方法中传递字节输出流
        2、使用ObjectOutputStream中的方法writeObject，把对象写入到文件中
        3、释放资源
 */
public class Demo04ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建ObjectOutputStream对象，构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
        //2.使用ObjectOutputStream对象中的方法writeObject，把对象写入到文件中。
        oos.writeObject(new Person("美好",19));
        //3.释放资源
        oos.close();

    }
}

反序列化主方法：

package Day01.demo04;

import java.io.*;

/*
    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文件
 */
public class Demo04ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1、创建ObjectInputStream对象，构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
        //2、使用ObjectInputStream对象中的方法readObject读取保存对象的文件
        Object o = ois.readObject();
        //3、释放资源
        ois.close();
        //4、使用读取出来的对象（打印）
        System.out.println(o);
        Person p = (Person)o;
        System.out.println(p.getName()+p.getAge());
    }
}

运行结果：
在这里插入图片描述
5.InvalidClassException异常
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
Person类：

package Day01.demo04;

import java.io.Serializable;

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

    static关键字：静态关键字
        静态优先于非静态加载到内存中（静态优先于对象进入到内存中）
        被static修饰的成员变量不能被序列化的，序列化的都是对象
        private static int age
        oos.writeObject(new Person("美好",19));
        Object o = ois.readObject();
        Person{name="美好",age=0}
    transient关键字：瞬态关键字
        被transient关键字修饰成员变量，不能被序列化。
        private transient int age
        oos.writeObject(new Person("美好",19));
        Object o = ois.readObject();
        Person{name="美好",age=0}
 */
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    //private static int age;
    //private transient int age;
    public int age;

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

    public Person() {
    }

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

}

序列化主方法：

package Day01.demo04;

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

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

    构造方法：
        ObjectOutputStream(OutputStream out) 创建写入指定outputStream的ObjectOutputStream。
        参数：
            OutputStream out:字节输出流

    特有的成员方法：
        void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。

    使用步骤：
        1、创建ObjectOutputStream对象，构造方法中传递字节输出流
        2、使用ObjectOutputStream中的方法writeObject，把对象写入到文件中
        3、释放资源
 */
public class Demo04ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建ObjectOutputStream对象，构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
        //2.使用ObjectOutputStream对象中的方法writeObject，把对象写入到文件中。
        oos.writeObject(new Person("美好",19));
        //3.释放资源
        oos.close();

    }
}

反序列化主方法：

package Day01.demo04;

import java.io.*;

/*
    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文件
 */
public class Demo04ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1、创建ObjectInputStream对象，构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
        //2、使用ObjectInputStream对象中的方法readObject读取保存对象的文件
        Object o = ois.readObject();
        //3、释放资源
        ois.close();
        //4、使用读取出来的对象（打印）
        System.out.println(o);
        Person p = (Person)o;
        System.out.println(p.getName()+p.getAge());
    }
}

运行结果：
在这里插入图片描述

6.练习：序列化集合

package Day01.demo04;

import java.io.*;
import java.lang.reflect.Field;
import java.util.ArrayList;

/*
    练习：序列化集合。
        当我们想在文件中保存多个对象的时候
        可以把多个对象存储到一个集合中
        对集合进行序列化和反序列化

    分析：
        1、定义一个存储Person对象的ArrayList集合
        2、往ArrayList集合中存储Person对象
        3、创建一个序列化流ObjectOutputStream对象
        4、使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化
        5、创建一个反序列化ObjectInputStream对象
        6、使用ObjectInputStream对象中的readObject读取文件中保存的集合
        7、把Object类型的集合转换为ArrayList类型
        8、遍历ArrayList集合
        9、释放资源

 */
public class Demo04Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1、定义一个存储Person对象的ArrayList集合
        ArrayList<Person> list = new ArrayList<>();
        //2、往ArrayList集合中存储Person对象
        list.add(new Person("张三",18));
        list.add(new Person("李四",19));
        list.add(new Person("王五",20));
        //3、创建一个序列化流ObjectOutputStream对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
        //4、使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化
        oos.writeObject(list);
        //5、创建一个反序列化ObjectInputStream对象
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream("list.txt"));
        //6、使用ObjectInputStream对象中的readObject读取文件中保存的集合
        Object o = ois.readObject();
        //7、把Object类型的集合转换为ArrayList类型
        ArrayList<Person> list2 = (ArrayList<Person>)o;
        //8、遍历ArrayList集合
        for (Person p : list2) {
            System.out.println(p);
        }
        //9、释放资源
        ois.close();
        oos.close();
    }
}

运行结果：
在这里插入图片描述
在这里插入图片描述

添砖 Java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python快速编程答案-100+Python编程题带你快速上手（附答案）
weixin_37988176的博客
11-01 457
春节马上就要到了，怎么能让自己在假期里不掉队？今天，给大家准备一个项目： 100+ 编程练习，这些题如果能坚持每天至少完成一道，一定可以帮大家轻松 get Python 的编程技能。目前，这个项目已经获得了 2924 Stars，2468 Forks。首先，这 100+ 练习题根据难易程度分为三个等级：Level 1、2 和 3。下面对如何定义这三个 Level 进行了说明，大家可以结合自身的学习...
自定义异常的两种方式
12-20
自定义异常的两种方式 一、抛出异常 def greet(name, city): if not isinstance(name, str): raise TypeError("Name must be str") if not isinstance(city, str): raise TypeError("Age must be str") print("My name is %s, and I come from" % (name, city)) greet(1, 2) 二、自定义异常（一） 调用父类Exception的__init
Java序列化ObjectOutputStream和反序列化ObjectInputStream详解（及关键字transient）
qq_43531919的博客
07-20 429
什么是序列化？？？ Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化： ObjectOutputStream类 java.io.ObjectOutputStream extends OutputStre
第五题
weixin_34032792的博客
03-21 326
题目： 定义一个至少包含2个方法的类，其中：getString：从控制台获取字符串，printString：把字符串大写输出。 提示： 使用__init__方法构造参数。 参考： class InputOutString(object): def __init__(self): self.s='' def getString(self...
Java序列化（ObjectOutputStream）和反序列化（ObjectInputStream）
qq_52040525的博客
04-08 413
序列化：用ObjectOutputStream类保存基本类型数据或对象的机制 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制 ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量 以String为例测试 package mytest; import java.io.FileOutputStream; import java.io.IOException; import java.io.Object
Java对象的序列化与反序列化Java开发Java经验技巧
11-22
- **用途**：Java提供了`transient`关键字，用于标记类的某个字段不参与序列化和反序列化。 - **应用场景**：例如，某些字段可能包含敏感信息，不适合在网络上传输，或者字段的值可以通过其他方式重新计算得到。 ...
JAVA序列化Serializable及Externalizable区别详解
08-18
对需要序列化的类实现Serializable即可，对于不希望进行序列化的，可以使用transient关键词进行修饰（即瞬时变量）。这种方式序列化的特征是：Serializable接口仅仅是一个标记接口，不包含任何方法；对于...
详解Java 对象序列化和反序列化
08-30
Java对象序列化的简化代码主要体现在使用`ObjectOutputStream`和`ObjectInputStream`这两个流。在上面的例子中，我们看到，通过`writeObject()`方法可以直接将一个对象写入文件，而`readObject()`则能从文件中恢复...
Java序列化(Serialization) 机制
09-02
`serialVersionUID`是一个长整型变量，用于版本控制，当类的结构发生变化时，如果`serialVersionUID`未变，则反序列化时会抛出`InvalidClassException`异常，提示序列化版本ID不匹配。 序列化机制还支持“深复制”...
java serializable 序列化与反序列化
05-22
- ** transient 关键字**：如果某个字段不需要序列化，可以使用`transient`关键字修饰。序列化时，这些字段会被忽略。 - **readObject() 和 writeObject()** 方法：可以覆盖这两个方法来自定义序列化和反序列化的...
Java ObjectInputStream readObject（）方法（带示例）
06-29 2853
ObjectInputStream类readObject()方法 (ObjectInputStream Class readObject() method) readObject() method is available in java.io package. readObject()方法在java.io包中可用。 readObject() method is used to read an ...
21.3 序列化流ObjectOutputStream与反序列化流ObjectInputStream、打印流PrintStream、 改变输出语句的目的地
Birdlun的博客
09-06 301
目录 序列化与反序列化 对象序列化流：ObjectOutputStream类 构造方法 常用方法 序列化操作 列：序列化练习 反序列化流：ObjectInputStream 构造方法 常用方法 反序列化出现异常的解决方案 ClassNotFoundException 异常 InvalidClassException异常 列：序列化与反序列化练习 列：集合的序列化与反序列化练习 打印流PrintStream 构造方法 列：打印流练习 改变输出语句的目的地 序列化与...
Java的IO操作（三） - 对象的序列化、ObjectInputStream和ObjectOutputStream类
王鸿飞的专栏
04-01 2659
由于Java是一种完全面向对象的高级语言，所以在编写程序的时候数据大都存放在对象当中。我们有时会需要将内存中的整个对象都写入到文件中去，然后在适当的时候再从文件中将对象还原至内存。我们可以使用java.io.ObjectInputStream和java.io.ObjectOutputStream类来完成这个任务。 1、对象的序列化(Serialize) 序列化是指将对象的状态信息转换为
ObjectInputStream的readObject方法出现java.lang.ClassNotFoundException
renwudao24的专栏
07-25 8105
在利用java socket实现Android客户端与服务端（笔记本）实现传递object对象时，需要用到ObjectInputStream以及ObjectOutputStream，当然传递的对象需要序列化，这是最重要的。 参考博文：Java Socket实战之三 传输对象 在调试过程中，在使用ObjectInputStream的readObject方法出现了java.lang.Cla
python类的应用-作业
qy00131717的博客
02-15 350
https://blog.csdn.net/weixin_43379056/article/details/86717780 问 创建一个类，在类中定义两个方法， 1 geiString要能接收字符串 2 printString 要能把输入的内容转化成大写，并且输出打印 这题难度就是要找到一个方法能将小写的字母转换成大写，后来我搜到了一个方法叫upper 知识点 upper 方法 - 能将字符...
Java IO之对象的序列化、ObjectInputStream和ObjectOutputStream类
热门推荐
koozxcv的博客
02-24 1万+
什么是IO流？  byte序列的读写，Java中的IO流是实现输入/输出的基础. Java将数据从源（文件、内存、键盘、网络）读入到内存 中，形成了流，然后将这些流还可以写到另外的目的地（文件、内存、控制台、网络），之所以称为流，是因为这个数据序列在不同时刻所操作的是源的不同部分。按照不同的分类标准，IO流分为不同类型。主要有以下几种方式：按照数据流方向、数据处理的单位和功能。 不管
Java笔记：序列化、反序列化、ObjectOutputStream类、ObjectInputStream类
sc179的博客
11-02 266
目录1 概述2 ObjectOutputStream类2.1 构造方法2.2 序列化条件2.3 写出对象方法3 ObjectInputStream类3.1 构造方法3.2 读入对象方法3.3 反序列化异常及处理4 练习：序列化集合4.1 案例分析4.2 案例实现 1 概述 Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。 反之，该字节序列还可以从文件中读取回来，
java基础 ---- ObjectOutputStream序列化流，ObjectInputStream反序列化流
m0_46523928的博客
07-18 1636
ObjectStream的使用概述： OutputStream的子类之一ObjectOutputStream（对象的序列化流），作用是把对象以流的方式写入到文件中保存。 有构造方法: -ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。参数:OutputStream out:字节输出流。 特有的成员方法: -void writeObject(Object obj) ...
java IO流之对象流ObjectInputStream ObjectInputStream 自定义类 Serializable 序列化与反序列化
SKPrimin的博客
08-15 722
java IO流之对象流ObjectInputStream ObjectInputStream 对象流：用于存储和读取基本数据类型数据或对象的处理流。 它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。 序列化和反序列化： ObjectOutputStream 类 ： 把内存中的Java对象转换成平台无关的二进制数据，从而允许把这种二进制数据持久地保存在磁盘上，或通过网络将这种二进制数据传输到另一个网络节点。序列化 ObjectInputStream类 ： 当其它
使用ObjectInputStream和ObjectOutputStream进行序列化和反序列化java
最新发布
02-06
ObjectInputStream和ObjectOutputStream类可以用来在Java中进行序列化和反序列化。序列化是将Java对象的状态保存到存储媒体（如磁盘、网络或其他连接）中，反序列化则是将存储在存储媒体中的对象状态重新读入到Java...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值