IO 流

最新推荐文章于 2023-06-11 20:05:01 发布
最新推荐文章于 2023-06-11 20:05:01 发布
阅读量103 收藏
点赞数
分类专栏： # JavaSE 文章标签： IO 流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bm1998/article/details/117593848
版权

文章目录

1. File 类

1.1 File 类概述和构造方法

File：它是文件和目录路径名的抽象表示

  • 文件和目录是可以通过 File 封装成对象的
  • 对于 File 而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的。

构造方法如下：

方法名说明
File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例
File(String parent, String child)从父路径名字符串和子路径名字符串创建新的 File 实例
File(File parent, String child)从父抽象路径名和子路径名字符串创建新的 File 实例

实例如下：

// File(String pathname)
File file1 = new File("D:\\file_test\\file.txt");

// File(String parent, String child)
File file2 = new File("D:\\file_test", "file.txt");

// File(File parent, String child)
File file3 = new File("D:\\file_test");
File file4 = new File(file3, "file.txt");

1.2 File 类创建功能

方法名说明
public boolean createNewFile()当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
public boolean mkdir()创建由此抽象路径名命名的目录
public boolean mkdirs()创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

实例如下：

// 需求 1：在 D:\file_test 目录下创建文件 file.txt
File file1 = new File("D:\\file_test\\file.txt");
System.out.println(file1.createNewFile());

// 需求 2：在 D:\file_test 目录下创建目录 demo1
File file2 = new File("D:\\file_test\\demo1");
System.out.println(file2.mkdir());

// 需求 3：在 D:\file_test 目录下创建多级目录 demo2\test
File file3 = new File("D:\\file_test\\demo2\\test");
System.out.println(file3.mkdirs());

1.3 File 类删除功能

方法名说明
public boolean delete()删除由此抽象路径名表示的文件或目录

绝对路径和相对路径的区别

  • 绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：E:\itcast\java.txt
  • 相对路径：必须使用取自其他路径名的信息进行解释。例如：myFile\java.txt

删除目录时的注意事项：

  • 如果一个目录中有内容(目录，文件)，不能直接删除。应该先删除目录中的内容，最后才能删除目录。

实例如下：

// 需求 1：在当前模块目录下创建 file1.txt 文件，然后删除该文件
File file1 = new File("file1.txt");
file1.createNewFile();
System.out.println(file1.delete());

// 需求 2：在当前模块目录下创建 demo 目录，然后删除该目录
File file2 = new File("demo");
file2.mkdir();
System.out.println(file2.delete());

// 需求 3：在当前模块目录下创建 demo\file1.txt 文件，然后删除该目录及文件
File file3 = new File("demo");
file3.mkdirs();
File file4 = new File(file3, "file1.txt");
file4.createNewFile();
System.out.println(file4.delete());
System.out.println(file3.delete());

1.4 File 类判断和获取功能

方法名说明
public boolean isDirectory()测试此抽象路径名表示的 File 是否为目录
public boolean isFile()测试此抽象路径名表示的 File 是否为文件
public boolean exists()测试此抽象路径名表示的 File 是否存在
public String getAbsolutePath()返回此抽象路径名的绝对路径名字符串
public String getPath()将此抽象路径名转换为路径名字符串
public String getName()返回由此抽象路径名表示的文件或目录的名称
public String[] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组

实例如下：

File file1 = new File("file.txt");
file1.createNewFile();
System.out.println(file1.isDirectory()); // flase
System.out.println(file1.isFile()); // true
System.out.println(file1.exists()); // true
System.out.println(file1.getAbsolutePath()); // D:\idea_workspace\io\filetest\file.txt
System.out.println(file1.getPath()); // file.txt
System.out.println(file1.getName()); // file.txt
System.out.println("----------");

File file2 = new File("src");
String[] list = file2.list();
Arrays.stream(list).forEach(System.out::println); // 打印 src 目录下的目录名和文件名
System.out.println("----------");

File[] files = file2.listFiles();
Arrays.stream(files)
    .filter(file -> file.isFile())
    .forEach(file -> System.out.println(file.getName())); // 只打印 src 目录下的文件名

1.5 案例：遍历目录

需求

给定一个路径(C:\Users\admin\Desktop\毕业设计)，请通过递归完成遍历该目录下的所有内容，并把所有文件的文件名输出在控制台。

思路

  1. 根据给定的路径创建一个 File 对象
  2. 定义一个方法，用于获取给定目录下的所有内容，参数为第 1 步创建的 File 对象
  3. 获取给定的 File 目录下所有的文件或者目录的 File 数组
  4. 遍历该 File 数组，得到每一个 File 对象
  5. 判断该 File 对象是否是目录
    1. 是：递归调用
    2. 不是：获取文件名输出在控制台
  6. 调用方法

代码实现

public class FileTest5 {
    public static void printFileName(File file) {
        Arrays.stream(file.listFiles()).forEach(file1 -> {
            if (file1.isFile()) {
                System.out.println(file1.getName());
            } else {
                printFileName(file1);
            }
        });
    }

    public static void main(String[] args) {
        File file = new File("C:\\Users\\admin\\Desktop\\毕业设计");
        printFileName(file);
    }
}

2. 字节流

2.1 IO 流概述和分类

IO 流概述

  • IO：输入/输出(Input/Output)
  • 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输。
  • IO 流就是用来处理设备间数据传输问题的，常见的应用：文件复制；文件上传；文件下载。

IO 流分类

按照数据的流向分类：

  • 输入流：从硬盘读数据到内存
  • 输出流：从内存写数据到硬盘

按照数据类型分类：

  • 字节流
  • 字符流

那么这两种流都在什么情况下使用呢？

  • 如果数据通过 Window 自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流
  • 否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

2.2 字节流写数据

字节流抽象基类

  • InputStream：这个抽象类是表示字节输入流的所有类的超类
  • OutputStream：这个抽象类是表示字节输出流的所有类的超类

子类名特点：子类名称都是以其父类名作为子类名的后缀

字节流输出子类

  • FileOutputStream：文件输出流用于将数据写入 File

    构造方法：FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

需求

向 file1.txt 文件中写入 97

使用字节输出流写数据的步骤：

  1. 创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
  2. 调用字节输出流对象的写数据方法
  3. 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）

实例如下：

/* 创建字节输出流对象，完成以下三件事：
   1. 调用系统功能创建文件
   2. 创建字节输出流对象
   3. 将字节输出流对象指向创建好的文件
*/
FileOutputStream ops = new FileOutputStream("file1.txt");
// 向文件写入 97
ops.write(97);
// 最后释放资源
ops.close();

2.3 字节流写数据的 3 种方式

方法名说明
void write(int b)将指定的字节写入此文件输出流一次写一个字节数据
void write(byte[] b)将 b.length 字节从指定的字节数组写入此文件输出流一次写一个字节数组数据
void write(byte[] b, int off, int len)将 len 字节从指定的字节数组开始，从偏移量 off 开始写入此文件输出流一次写一个字节数组的部分数据

2.4 字节流写数据的两个小问题

  1. 字节流写数据如何实现换行呢？

    写完数据后，加换行符

    • windows:\r\n
    • linux:\n
    • mac:\r

    实例如下：

    FileOutputStream ops = new FileOutputStream("file.txt");
for (int i = 0; i < 5; i++) {
    // 写入 5 行 hello，并实现换行
    ops.write("hello\r\n".getBytes());
}
ops.close();

  2. 字节流写数据如何实现追加写入呢？

    • public FileOutputStream(String name,boolean append)
    • 创建文件输出流以指定的名称写入文件。如果第二个参数为 true ，则字节将写入文件的末尾而不是开头

    实例如下：

    FileOutputStream ops = new FileOutputStream("file.txt", true);
for (int i = 0; i < 5; i++) {
    // 追加 5 行 world，并实现换行
    ops.write("world\r\n".getBytes());
}
ops.close();

2.5 字节流写数据加异常处理

之前采取的都是抛出异常的方式，接下来演示一下捕获异常的处理方式：

FileOutputStream ops = null;
try {
    ops = new FileOutputStream("file.txt");
    ops.write("hello".getBytes());
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (ops != null) {
        try {
            ops.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

从 Java 7 开始支持 try-with-resources 语句，称为 ARM 块(Automatic Resource Management) ，自动资源管理。也就是说，数据流会在 try 执行完毕后自动被关闭。

上面的程序可以简化如下：

try(FileOutputStream osp = new FileOutputStream("file.txt")) {
    osp.write("hello".getBytes());
} catch (IOException e) {
    e.printStackTrace();
}

2.6 字节流读数据(一次读一个字节数据)

字节输入流

  • FileInputStream：从文件系统中的文件获取输入字节

字节输入流子类

  • FileInputStream(String name)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name 命名

一次读一个字节数组的方法

  • public int read()：从输入流读取数据的下一个字节。
  • 返回的是读取到的数据，如果没有字节可用，因为已经到达流的末尾，则返回值 -1。

需求

把文件 file.txt 中的内容读取出来在控制台输出

使用字节输入流读数据的步骤：

  1. 创建字节输入流对象
  2. 调用字节输入流对象的读数据方法
  3. 释放资源

实例如下：

FileInputStream ips = new FileInputStream("file.txt");

int by;
while ((by = ips.read()) != -1) {
    System.out.print((char) by);
}
ips.close();

2.7 案例：复制文本文件

需求

把 “file.txt” 复制到模块目录下的 “newfile.txt”

思路

复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)

代码实现

FileOutputStream ops = new FileOutputStream("newfile.txt");
FileInputStream ips = new FileInputStream("file.txt");

int by;
while ((by = ips.read()) != -1) {
    ops.write(by);
}

ips.close();
ops.close();

2.8 字节流读数据(一次读一个字节数组数据)

一次读一个字节数组的方法：

  • public int read(byte[] b)：从输入流读取最多 b.length 个字节的数据
  • 返回的是读入缓冲区的总字节数，也就是实际的读取字节个数

将上面的案例改造为一次读一个字节数组数据，实例如下：

FileOutputStream ops = new FileOutputStream("newfile.txt");
FileInputStream ips = new FileInputStream("file.txt");

byte[] bys = new byte[1024];
int i;
while ((i = ips.read(bys)) != -1) {
    // 注意：写入的为实际读取的长度，而不是整个数组的长度
    ops.write(bys, 0, i);
}

ips.close();
ops.close();

2.9 字节缓冲流

读取数据量大的文件时，读取的速度会很慢，很影响我们程序的效率，Java 中提高了一套字节缓冲流，它可以提高 IO 流的读写速度。

创建 BufferedInputStream 和 BufferedOutputStream 两个缓冲流对象，这两个流都对应了一个大小为 8192 的字节数组，当调用 read() 或者 write() 方法读写数据时，首先将读写的数据存入定义好的字节流数组，然后将字节数组的数据一次性的读写到文件中。

从内存写数据到文件，相当于将一缸水倒入另外一个缸中：

  • FileOutputStream 的 write 方法：相当于一滴一滴地把水转移过去。
  • BufferOutputStream 的 write 方法：相当于一瓢一瓢先把水放入的桶中，再将桶中的水倒入缸中，性能提高了。

字节缓冲流：

  • BufferOutputStream：该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
  • BufferedInputStream：创建 BufferedInputStream 将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法：

  • 字节缓冲输出流：BufferedOutputStream(OutputStream out)
  • 字节缓冲输入流：BufferedInputStream(InputStream in)

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

  • 字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

2.10 案例：复制视频

需求

把 “C:\Users\admin\Downloads\Video\老大.mp4” 复制到模块目录下的 “video.mp4”，分别采用基本的字节流和字节缓冲流实现，并测试它们的耗时。

代码实现

public class BufferedInputStreamTest {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String ips = "C:\\Users\\admin\\Downloads\\Video\\老大.mp4";
        String ops = "video.mp4";
//        method1(ips, ops); // 12296
//        method2(ips, ops); // 19
//        method3(ips, ops); // 6277
//        method4(ips, ops); // 13
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    // 普通字节流，一次读一个字节数据
    public static void method1(String ips, String ops) {
        try (InputStream inputStream = new FileInputStream(ips);
             OutputStream outputStream = new FileOutputStream(ops)) {
            int by;
            while ((by = inputStream.read()) != -1) {
                outputStream.write(by);
                outputStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 普通字节流，一次读一个字节数组数据
    public static void method2(String ips, String ops) {
        try (InputStream inputStream = new FileInputStream(ips);
             OutputStream outputStream = new FileOutputStream(ops)) {
            byte[] bytes = new byte[1024];
            int i;
            while ((i = inputStream.read(bytes)) != -1) {
                outputStream.write(bytes, 0, i);
                outputStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 字节缓冲流，一次读一个字节数据
    public static void method3(String ips, String ops) {
        try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(ips));
             BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(ops))) {
            int by;
            while ((by = inputStream.read()) != -1) {
                outputStream.write(by);
                outputStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 字节缓冲流，一次读一个字节数组数据
    public static void method4(String ips, String ops) {
        try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(ips));
             BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(ops))) {
            byte[] bytes = new byte[1024];
            int i;
            while ((i = inputStream.read(bytes)) != -1) {
                outputStream.write(bytes, 0, i);
                outputStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

分析：从耗时上来看，字节缓冲流提高 IO 流的读写速度。

2.11 案例：复制多级目录

需求

把 “C:\Users\admin\Desktop\毕业设计” 这个文件夹复制到 “D:” 下

思路

  1. 创建数据源 File 对象，路径是 C:\Users\admin\Desktop\毕业设计
  2. 创建目的地 File 对象，路径是 D:\
  3. 写方法实现文件夹的复制，参数为数据源 File 对象和目的地 File 对象，判断数据源 File 是否是文件
    1. 是文件：用字节流直接复制
    2. 不是文件：
      1. 在目的地下创建该目录
      2. 遍历获取该目录下的所有文件的 File 数组，得到每一个 File 对象
      3. 继续递归

代码实现

public class CopyFolder {
    public static void main(String[] args) {
        // 源文件
        File sourceFile = new File("C:\\Users\\admin\\Desktop\\毕业设计");
        // 目标文件
        File targetFile = new File("D:\\");
        // 复制多级目录
        copyFolder(sourceFile, targetFile);
    }

    private static void copyFolder(File sourceFile, File targetFile) {
        // 是文件，用字节流直接复制
        if (sourceFile.isFile()) {
            try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(sourceFile));
                 BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(new File(targetFile, sourceFile.getName())))
            ) {
                byte[] bytes = new byte[1024];
                int i;
                while ((i = inputStream.read(bytes)) != -1) {
                    outputStream.write(bytes, 0, i);
                    outputStream.flush();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            // 不是文件，新建目录
            File newFolder = new File(targetFile, sourceFile.getName());
            if (!newFolder.exists()) {
                newFolder.mkdir();
            }
            // 继续递归
            Arrays.stream(sourceFile.listFiles()).forEach(file -> copyFolder(file, newFolder));
        }
    }
}

3. 字符流

3.1 为什么会出现字符流

由于字节流操作中文不是特别的方便，所以 Java 就提供字符流。

  • 字符流 = 字节流 + 编码表

用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？

  • 汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数。

3.2 编码和解码

  • 计算机中储存的信息都是用二进制数表示的；我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果。
  • 按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。
  • 这里强调一下：按照 A 编码存储，必须按照 A 编码解析，这样才能显示正确的文本符号。否则就会导致乱码现象。

3.3 字符串中的编码解码

编码：

  • byte[] getBytes()：使用平台的默认字符集将该 String 编码为一系列字节，将结果存储到新的字节数组中
  • byte[] getBytes(String charsetName)：使用指定的字符集将该 String 编码为一系列字节，将结果存储到新的字节数组中

解码：

  • String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的 String
  • String(byte[] bytes, String charsetName)：通过指定的字符集解码指定的字节数组来构造新的 String

实例如下：

String str = "中国";
byte[] bytes1 = str.getBytes("UTF-8");
byte[] bytes2 = str.getBytes("GBK");
System.out.println("以 UTF-8 方式编码：" + Arrays.toString(bytes1));
System.out.println("以 GBK 方式编码：" + Arrays.toString(bytes2));
//
System.out.println("以 UTF-8 方式解码：" + new String(bytes1, "UTF-8"));
// 以 GBK 方式解码
System.out.println("以 GBK 方式解码：" + new String(bytes2, "GBK"));

运行结果：

以 UTF-8 方式编码：[-28, -72, -83, -27, -101, -67]
以 GBK 方式编码：[-42, -48, -71, -6]
以 UTF-8 方式解码：中国
以 GBK 方式解码：中国

3.4 字符流中的编码解码

字符流抽象基类：

  • Reader：字符输入流的抽象类
  • Writer：字符输出流的抽象类

字符流中和编码解码问题相关的两个类：

  • InputStreamReader：是从字节流到字符流的桥：它读取字节，并使用指定的 charset 将其解码为字符 。它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
  • OutputStreamWriter：是字符的桥梁流以字节流：向其写入的字符编码成使用指定的字节 charset。它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。

实例如下：

OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("text.txt"), "GBK");
writer.write("中国");
writer.close();

InputStreamReader reader = new InputStreamReader(new FileInputStream("text.txt"), "GBK");
// 一次读取一个字符数据
int ch;
while ((ch = reader.read()) != -1) {
    System.out.print((char) ch);
}
// 一次读取一个字符数组数据
// char[] chars = new char[1024];
// int i;
// while ((i = reader.read(chars)) != -1) {
//   System.out.print(new String(chars, 0, i));
// }
reader.close();

运行结果：

中国

3.5 字符流写数据的 5 种方式

方法名说明
void write(int c)写一个字符
void write(char[] cbuf)写入一个字符数组
void write(char[] cbuf, int off, int len)写入字符数组的一部分
void write(String str)写一个字符串
void write(String str, int off, int len)写一个字符串的一部分
flush()刷新流，还可以继续写数据
close()关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据

3.6 字符流读数据的 2 种方式

方法名说明
int read()一次读一个字符数据
int read(char[] cbuf)一次读一个字符数组数据

3.7 案例：复制文本文件

需求

把 scr 下的 “InputStreamReaderTest1.java” 复制到当前模块目录下的 “Copy.java”

思路

转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类：

  • FileReader(String fileName)：用于读取字符文件的便捷类
  • FileWriter(String fileName)：用于写入字符文件的便捷类

代码实现

FileReader reader = new FileReader("src\\InputStreamReaderTest1.java");
FileWriter writer = new FileWriter("Copy.java");

char[] chars = new char[1024];
int i;
while ((i = reader.read(chars)) != -1) {
    writer.write(chars, 0, i);
    writer.flush();
}

reader.close();
writer.close();

3.8 字符缓冲流

字符缓冲流：

  • BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
  • BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

构造方法：

  • BufferedWriter(Writer out)
  • BufferedReader(Reader in)

3.9 字符缓冲流特有功能

BufferedWriter：

  • void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义

BufferedReader：

  • public String readLine() ：读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为 null

3.10 案例：复制文本文件（字符缓冲流特有功能改进版）

需求

把 scr 下的 “InputStreamReaderTest1.java” 复制到当前模块目录下的 “Copy.java”

代码实现

BufferedReader reader = new BufferedReader(new FileReader("src\\InputStreamReaderTest1.java"));
BufferedWriter writer = new BufferedWriter(new FileWriter("Copy.java"));

String line;
while ((line = reader.readLine()) != null) {
    writer.write(line);
    writer.newLine();
    writer.flush();
}

reader.close();
writer.close();

4. IO 流总结

在这里插入图片描述
在这里插入图片描述

5. 对象序列化

5.1 对象序列化流

  • 序列化：就是将对象保存到磁盘中，或者在网络中传输对象
  • 反序列化：该字节序列还可以从文件中读取回来，重构对象

要实现序列化和反序列化就要使用对象序列化流和对象反序列化流。

对象序列化流：ObjectOutputStream

  • 构造方法：
    ObjectOutputStream(OutputStream out)：创建一个写入指定的 OutputStream 的 ObjectOutputStream
  • 序列化对象的方法：
    void writeObject(Object obj)：将指定的对象写入 ObjectOutputStream

注意：

  • 一个对象要想被序列化，该对象所属的类必须必须实现 Serializable 接口
  • Serializable 是一个标记接口，实现该接口，不需要重写任何方法

对象反序列化流：ObjectInputStream

  • 构造方法：
    ObjectInputStream(InputStream in)：创建从指定的 InputStream 读取的 ObjectInputStream
  • 反序列化对象的方法：
    Object readObject()：从 ObjectInputStream 读取一个对象

实例如下：

ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("file.txt"));
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("file.txt"));

outputStream.writeObject(new Student("jack", 18));
Object object = inputStream.readObject();
Student student = (Student) object;
System.out.println(student.getName() + " " + student.getAge());

outputStream.close();
inputStream.close();

运行结果：

jack 18

5.2 对象序列化的问题

  • 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？

    会出问题，会抛出 InvalidClassException 异常

  • 如果出问题了，如何解决呢？

    重新序列化，给对象所属的类加一个 serialVersionUID 属性

    private static final long serialVersionUID = 42L;

  • 如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？

    给该成员变量加 transient 关键字修饰，该关键字标记的成员变量不参与序列化过程

bm1998
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
什么是IO流？
lihoo747的博客
10-27 6876
大家好，我是IT修真院北京分院第27期的JAVA学员，一枚正直纯洁善良的java程序员。 今天给大家分享一下，修真院官网Java任务10，深度思考中的知识点———什么是IO流？   1.背景介绍 什么是流 流就是一系列的数据 当不同的介质之间有数据交互的时候，JAVA就使用流来实现。 数据源可以是文件，还可以是数据库，网络甚至是其他的程序。 比如读取文件的数据到程序中，站在程序的角度来...
Java中的IO流
12-22
一、 什么是IO流 一般情况下是按照当前程序使用的内存为参照物来考虑数据的走向问题。 以文件操作为例 从内存中保存数据到硬盘 output 从硬盘中读取数据到内存 input 看视频，缓冲 使用缓冲可以让用户体验提高，相对...
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 14万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
io流
qq_40977337的博客
05-09 3048
IO流 java.io包 1.什么是流？ io流就是java中运输数据的一种载体 它能够把数据从一个地方运输到另一个地方 2.流的分类 a 根据流运输数据的方向<以内存为参考物> 输入流 输出流 b 根据数据传输时转换的类型 字节流 byte 字符流 char ...
Java io流 详解
m0_68987535的博客
06-11 4463
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
JavaIO流详解
itqcyyl的博客
08-09 2万+
转载：https://www.cnblogs.com/LittleHann/p/3678685.html Java输入、输入、IO流 类层次关系梳理 本文主要关注在Java编程中涉及到的IO相关的类库、方法。以及对各个层次(抽线、接口继承)的流之间的关系进行梳理   相关学习资料 http://baike.baidu.com/view/1007958.htm?noadapt=1 h...
IO流的分类
小白学编程
05-11 1万+
IO流的分类可以分为以下三种： 第一种：输入流和输出流 按照流的流向来分，可以分为输入流和输出流。输入，输出都是从程序运行所在内存的角度来划分的。 输入流：只能从中读取数据，而不能向其写入数据，由InputStream和Reader作为基类。 输出流：只能向其写入数据，而不能从中读取数据。由OutputStream和Writer作为基类 第二种：字节流和字符流 字节流和字符流的用法几乎完全一样，区...
Java IO流（超详细！）
一只小菜鸡
05-07 5万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
IO流概述
m0_70905607的博客
07-16 3018
Ooutput，是内存程序的数据从内存到写出到硬盘文件的过程，称之输出、负责写。Iinput，是数据从硬盘文件读入到内存的过程，称之为输入，负责读。以内存为基准，把磁盘文件中的数据以字符的形式读取到内存中。定义一个与文件一样大的数组，一次性读取完文件的全部字节。读取中文字符不会出现乱码（如果文件和代码的编码一致）（3）文件字符输入流（FileReader）的作用。（4）直接把文件数据全部读取到一个字节数组怎样？字节流适合做一切文件数据的拷贝（音视频、文本）（5）字节输出流如何实现写出去的数据能换行？...
IO流详解.
lwj_07的博客
04-01 5871
一、IO流概述 IO流： 什么是IO？ I：Input O：Output (断电内存数据消失) 二、IO流的分类 Io流的分类? 有多种分类方式: 一种方式是按照流的方向进行分类: 以内存作为参照物,往内存中去，叫做输入(Input)。或者叫做读(Read)。从内存中出来，叫做输出(Output)。或者叫做写(Write) 另一种方式是按照读取数据方式不同进行分类: 有的流是按照字节的方式读取数据，一次读取1个字节byte,等同于一次读...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
java IO流文件的读写具体实例
09-04
Java IO流是Java平台中用于处理输入输出的重要机制，它允许程序与各种数据源和目的地进行交互，包括文件、网络连接、系统硬件等。在Java中，IO流分为四个主要类别，分别是字节流（处理二进制数据）、字符流（处理...
IO流的主要流
07-12
Java中的IO流主要负责在不同数据源之间进行数据的传输，包括从文件系统、网络、内存等地方读取数据，以及向这些地方写入数据。IO流被设计为双工通道，既可以进行输入操作，也可以进行输出操作。Java的IO流体系结构...
java IO流详细笔记
07-12
Java IO流详解
pyzmq-26.0.0b2-cp312-cp312-manylinux_2_28_x86_64.whl
06-19
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
C++冒泡排序（基础内容）
06-19
1.循环两个变量：外层（轮数）、内层每轮的次数； 2.总轮数=元素长度-1=最大下标 3.每轮次数=元素长度-1-轮数=最大下标-轮数； 4.轮数（++），次数（++）； 5.两两交换，大的放后面 冒泡排序基础内容，自学可用； 分为三个部分，推到过程，总结，题目样例 很详细，欢迎一起学习交流
pyzmq-25.1.0-cp36-cp36m-win32.whl
最新发布
06-19
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
protobuf-3.20.3-cp38-cp38-win_amd64.whl
06-19
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
Android io流
08-30
Android中的IO流指的是输入输出流，用于读取和写入数据。在Android开发中，常用的IO流有FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等。 FileInputStream和FileOutputStream用于读取和写入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bm1998

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值