--- aliases: [] tags: - java - io - PL - base created: 2024-01-19 17:01:19 modified: 2024-07-13 11:24:13 --- # Java IO 笔记 --- ## IO 模型 Unix/[Linux](../Linux/Linux_Note.md) 下有 5 种 IO 模型： * Blocking IO * Nonblocking IO * IO multiplexing * Signal driven IO * Asynchronous IO ### 一些概念 ### BIO BIO（BLocking IO）顾名思义是一种阻塞型 IO 模型。 ### NIO NIO（Nonblocking IO ） 非阻塞 IO 模型。 ### 相关资料 * [看一遍就理解：IO模型详解 - 掘金](https://juejin.cn/post/7036518015462015006) * [5种网络IO模型（有图，很清楚） - 知乎](https://zhuanlan.zhihu.com/p/54580385) * [一文读懂网络 IO 模型原理 - 掘金](https://juejin.cn/post/7287791555623190568) ## 传统 IO java 传统 io 使用的是 [BIO](#BIO) 模型。 ### IO 相关类图 #### InputStream 类图 ```mermaid classDiagram class InputStream { <> +read(byte[] b) int +read(byte[] b, int off, int len) int } class FileInputStream { FileInputStream(File file) +read(byte[] b) int +read(byte[] b, int off, int len) int } class FilterInputStream { #FilterInputStream(InputStream in) +read(byte[] b) int +read(byte[] b, int off, int len) int } class BufferedInputStream { BufferedInputStream(InputStream in) BufferedInputStream(InputStream in, int size) +read(byte[] b, int off, int len) int } InputStream <|-- FileInputStream InputStream <|-- FilterInputStream FilterInputStream <| -- BufferedInputStream ``` #### OutputStream 类图 ```mermaid classDiagram class OutputStream { <> +write(byte[] b) void +write(byte[] b, int off, int len) void } class FileOutputStream { FileOutputStream(File file) FileOutputStream(File file, boolean append) FileOutputStream(String name) FileOutputStream(String name, boolean append) +write(byte[] b) void +write(byte[] b, int off, int len) void } class FilterOutputStream { FilterOutputStream(OutputStream out) +write(byte[] b) void +write(byte[] b, int off, int len) void } class BufferedOutputStream { BufferedOutputStream(OutputStream out) BufferedOutputStream(OutputStream out, int size) +write(byte[] b, int off, int len) void } OutputStream <| -- FileOutputStream OutputStream <| -- FilterOutputStream FilterOutputStream <| -- BufferedOutputStream ``` ### File Java 构造一个 `File` 对象，即使传入的文件或目录不存在，代码也不会出错，因为这个对象只是 Java 在内存中构建的一个对象。 因为构造一个 `File` 对象，并不会导致任何磁盘操作，而只有当调用 `File` 对象的某些方法的时候，才真正进行 IO 操作。 #### 常见问题 ##### 关于 File 的空指针异常 示例： ```java try{ // File d01 = new File(File_E01.class.getResource("t02.txt").getPath()); // File d01 = new File("t02.txt"); // 获取对象的路径 System.out.println(d01.getPath()); // 获取对象的父级路径 System.out.println(d01.getParent()); } catch (NullPointerException e) { logger.severe("NullPointerException! 文件对像为Null!\n" + e.getMessage()); } ``` 可以看文档知道，`File` 类在构建时有可能会抛空指针异常（`Throws: NullPointerException - If the pathname argument is null`），前提是那个 pathname 的字符串为 `null`。 但实际上，除非故意传个 null 值给 File 的构造方法，基本不可能让 File 「new 空」。即便如上面示例一样，使用 `类.class.getResource("xxx").getPath()` 这种方式，获取地址值。而上面示例却有可能会触发抛出空指针异常。触发的原因不是 File 的构造方法，而是 `类.class.getResource("xxx").getPath()` 这里触发的。 当执行到 `类.class.getResource("xxx")` 这里时，如果 `getResource()` 的参数是一个不存在的路径，那 `getResource()` 就会返回个 null，null 是不能继续 `getPath()` 的，所以触发了空指针异常的抛出。所以在这种方式构建 File 对象，空指针异常抛出在路径字符串「获取」时就有可能触发了，File 的构造方法根本没机会再触发空指针异常。 还有 `类.class.getResource("xxx").getPath()` 这代码中的 `getPath()` 方法是不会返回 Null 值，它最多只会返回一个空字符串（`Returns: the path part of this `URL`, or an empty string if one does not exist`）。 #### 路径相关 获取文件路径的方式有多种： ##### 方式 1 ```java IO_E01.class.getResource("t01.txt").getPath() // 结果与getPath()是一致的，但toString()一般用于调试 //File_E01.class.getResource("t01.txt").toString() File_E01.class.getResource("").getPaht() // 返回的是File_E01类所在的目录路径 ``` ##### 方式 2 ```java System.out.println(this.getClass().getResource("")); System.out.println(this.getClass().getResource("/")); System.out.println(this.getClass().getResource("t01.txt")); System.out.println(this.getClass().getResource("/t01.txt")); // 结果 // file:/home/silascript/DevWorkSpace/JavaExercise/io_exercise/ // file:/home/silascript/DevWorkSpace/JavaExercise/io_exercise/ // file:/home/silascript/DevWorkSpace/JavaExercise/io_exercise/t01.txt // file:/home/silascript/DevWorkSpace/JavaExercise/io_exercise/t01.txt ``` ##### 方式 3 ```java System.out.println(this.getClass().getClassLoader().getResource("")); System.out.println(this.getClass().getClassLoader().getResource("t01.txt")); System.out.println(this.getClass().getClassLoader().getResource("/")); System.out.println(this.getClass().getClassLoader().getResource("/t01.txt")); // 结果 // file:/home/silascript/DevWorkSpace/JavaExercise/io_exercise/ // file:/home/silascript/DevWorkSpace/JavaExercise/io_exercise/t01.txt // null // null ``` > [!tip] > `this.getClass().getClassLoader().getResource(路径字符串)`，使用这个方式获取文件地址，不能以 `/`（根路径）开始，不然返回值只能是 `null` 。 > > 因为 `getClass().getClassLoader()` 这已经是表示 `/` 目录。 > [!info] 相关链接 > > * [java获取文件路径总结\_inputstream获取文件路径-CSDN博客](https://blog.csdn.net/qq_38747892/article/details/126751734) > * [Java中的getResource()方法，及路径相关问题](https://cloud.tencent.com/developer/article/1901321) ### 遍历 File 类中有两组方法：`list()` 和 `listFiles()` 用来遍历。 `list()` 的返回值是字符串数组，即文件或目录的名称。 `listFiles()` 的返回值是 File 类型的数组，即返回的是 File 的对象。 这两组方法的重载方法，都能接收 [FileFilter](#javaio_io_filter_filefilter) 和 [FilenameFilter](#javaio_io_filter_filenamefilter) 这两种 [过滤器](#javaio_io_filter)。 ### 过滤器 #### FilterInputStream `FilterInputStream` 是所有过滤输入流的所有类的父类。 观察 [InputStream 类图](#InputStream%20类图)，发现 `FilterInputStream` 的构造方法是 `protected` 的。也就是说除了其自身还有及子类外的第三方要创建它，是不能通过 `new FilterInputStream()` 来创建的，只能通过其子类，如 [BufferedInputStream](#字节缓冲流) 等子类来创建。 #### FilterOutputStream `FilterOutputStream` 是所有过滤输出流的所有类的父类。 #### FileFilter FileFilter 文件过滤器。 在 [JDK8](#JDK8) 后，FileFilter 接口被标记为 [函数式接口](#函数式接口)，所以可以使用 [Lambda](Java_Note.md#java_lambda) 语法去快速实现这个接口。 FileFilter 接口只有一个方法：`boolean accept(File pathname)`。参数只有一个，即传入一个要过滤的目录 File 对象。 > [!example] 示例 > > ```java > public class File_E03 { > > static Logger logger = Logger.getLogger("File_E03"); > > public static void main(String[] args) { > > try { > > // 当前类所在的目录 > File dir01 = new File(File_E03.class.getResource("").getPath()); > > // 获取所有java文件 > // listFiles() 方法得到的是File的数组 > File[] files = dir01.listFiles((f) -> f.getPath().endsWith(".java")); > > // 遍历 > for (File f_temp : files) { > System.out.println("文件名：" + f_temp.getName()); > System.out.println("文件绝对路径：" + f_temp.getAbsolutePath()); > System.out.println("文件路径：" + f_temp.getPath()); > > System.out.println("---------------------------------------"); > } > > } catch (NullPointerException e) { > > logger.severe(e.getMessage()); > > } > > } > } > > > ``` > #### FilenameFilter FilenameFilter 文件名过滤器。 在 [JDK8](Java_Note.md#JDK8) 后，FilenameFilter 接口被标记为 [函数式接口](Java_Note.md#函数式接口)，所以可以使用 [Lambda](Java_Note.md#java_lambda) 语法去快速实现这个接口。 这接口有且只有一个方法：`accept(File dir, String name)`。 > [!example] 列出某目录下所有 java 文件 > > ```java > public class File_E02 { > > static Logger logger = Logger.getLogger("File_E02"); > > public static void main(String[] args) { > > try { > > > // 当前类所在目录 > File f01 = new File(File_E02.class.getResource("").getPath()); > > // 列出此目录下所有后缀名为".java"的文件 > String[] files = f01.list((dir, fname) -> { > return fname.endsWith(".java"); > }); > > // 遍历文件名数组 > for (String fn_temp : files) { > > File f = new File(f01, fn_temp); > > if (f.isFile()) { > System.out.println("文件名：" + f.getName()); > System.out.println("文件绝对路径：" + f.getAbsolutePath()); > System.out.println("文件路径：" + f.getPath()); > } else { > System.out.println("子目录：" + f); > } > System.out.println("-----------------------------"); > } > > } catch (NullPointerException e) { > > logger.severe(e.getMessage()); > } > > } > > } > > ``` > 因为 FilenameFilter 接口已经被标记为函数式接口，所以示例代码中使用了 lambda 来定义这接口的实现。 > ### 字节流 #### 常用示例 ```java package io_exercise; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; public class IO_E01 { public static void main(String[] args) { try (InputStream inputStr = new FileInputStream( // 获取要读取的文件 IO_E01.class.getResource("t01.txt").getPath())) { // 用来装每次读取到的字符 // 字符数组大小决定每次读了多少字符 var bbuf = new byte[1024]; // 实际读取的字符数 var hasRead = 0; while ((hasRead = inputStr.read(bbuf)) > 0) { System.out.println(new String(bbuf, 0, hasRead)); } } catch (IOException e) { e.printStackTrace(); } } } ``` > [!tip] 关闭流 > > 在 [JDK1.7（即JDK7）](Java_Note#JDK) 之前的版本，需要手动关闭流，所以常常在 `finally` 代码块中执行 `inputStr.close()` 的代码。 > > 但从 1.7 开始，流接口已经实现了 `AutoCloseable` 接口，顾名思义，io 流已经可以「自动」关闭了，无须再手动写关闭流的代码了。 ### FileInputStream `FileInputStream` 是 [字节流](#javaio_io_bytestream) 抽象类 `InputStream` 的子类。 #### FileInputStream 与 InputStream 区别 `InputStream` 是字节流的抽象基类，它可以从任意的数据源中读取字节数据，包括内存、网络、文件等； `FileInputStream` 顾名思义，它只能从文件读取字节数据。 对比下两者部分源码对比： --- start-multi-column: ```column-settings Number of Columns: 2 Largest Column: standard ``` FileInputStream ```java private native int readBytes(byte[] b, int off, int len) throws IOException; @Override public int read(byte[] b) throws IOException { long comp = Blocker.begin(); try { return readBytes(b, 0, b.length); } finally { Blocker.end(comp); } } ``` --- end-column --- InputStream ```java public int read(byte[] b) throws IOException { return read(b, 0, b.length); } ``` --- end-multi-column 可发现，`FileInputStream` 的 `read(byte[] b)` 方法调了一个 native 方法 ### FileOutputStream `FileOutputStream` 比较重要的方法：`write(byte[] b, int off, int len)`。 #### FileInputStream 和 FileOutputStream 示例 ```java public class File_E05 { static Logger logger = Logger.getLogger("File_E05"); public static void main(String[] args) { // 要读取的文件 File fin = new File(File_E05.class.getResource("t01.txt").getPath()); // 要输出的文件 File fout = new File(File_E05.class.getResource("").getPath() + File.separator + "t01_backup.txt"); try (FileInputStream fis = new FileInputStream(fin); FileOutputStream fos = new FileOutputStream(fout)) { byte[] buffer = new byte[10]; int len = 0; while ((len = fis.read(buffer)) > 0) { String cpStr = new String(buffer); // 打印下 System.out.print(cpStr); // 写出 fos.write(buffer, 0, len); } } catch (FileNotFoundException fnfe) { logger.severe(fnfe.getMessage()); } catch (IOException ioe) { logger.severe(ioe.getMessage()); } catch (NullPointerException npe) { logger.severe(npe.getMessage()); } catch (Exception e) { logger.severe(e.getMessage()); } } } ``` ### 字节缓冲流 `BufferedInputStream` 与 `BufferedOutputStream` 称为字节缓冲流。使用内置的缓冲区对读取或输出的数据进行缓冲，以此减少直接读取数据源的次数。 `BufferedInputStream` 和 `BufferedOutputStream` 是 [FilterInputStream](#javaio_io_filter_filterinputstream) 与 [FilterOutputStream](#javaio_io_filter_filteroutputstream) 的子类。 字节缓冲流默认的缓冲区大小是**8M**。这个数值可能通过重载的构造方法进行设置：`public BufferedInputStream(InputStream in, int size)`。这个数值最好是 2 的 n 次幂。 > [!info] BufferedInputStream 源码 > > `private static final int DEFAULT_BUFFER_SIZE = 8192;` 这两类在对象实例化时，需要传入 [FileInputStream](#javaio_io_bytestream_fileinputstream) 和 [FileOutputStream](#javaio_io_bytestream_fileouputstream) 实例对象。 而其 `read()` 方法与 `write()` 方法用法与 `FileInputStream` 与 `FileOutputStream` 大同小异。 #### BufferedInputStream 与 BufferedOutputStream 示例 ```java // 类所在的目录路径 String current_path = File_E06.class.getResource("").getPath(); // 要读取的文件 File in_file = new File(current_path + File.separator + "t01.txt"); // 要输出的文件 File out_file = new File(current_path + File.separator + "t01_backup.txt"); // 读取数据字节缓存 byte[] buff = new byte[64]; int len = 0; try (FileInputStream fis = new FileInputStream(in_file); BufferedInputStream bis = new BufferedInputStream(fis); FileOutputStream fos = new FileOutputStream(out_file); BufferedOutputStream bos = new BufferedOutputStream(fos)) { // 读取 while ((len = bis.read(buff)) > 0) { // 输出 bos.write(buff, 0, len); } ``` --- ## NIO `java.nio` 是 [JDK 1.4](Java_Note.md#JDK) 就已经提供的。 ### Buffer `Buffer` 是 [NIO](#javaio_nio) 的核心。nio 的 API 都是围绕着 `Buffer` 而设计的。 ```mermaid classDiagram Buffer <|-- ByteBuffer class Buffer{ <> +position() int +position(int newPosition) Buffer +limit() int +limit(int newLimit) Buffer +flip() Buffer +remaining() int +capacity() int +clear() Buffer +hasRemaining() boolean +slice() Buffer +slice(int index, int length) Buffer +mark() Buffer +isDirect() boolean +isReadOnly() boolean } class ByteBuffer{ <> +allocate(int capacity) ByteBuffer +allocateDirect(int capacity) ByteBuffer +get() bype +get(byte[] dst) ByteBuffer +get(byte[] dst, int offset, int length) ByteBuffer +get(int index) bype +get(int index, bype[] dst) ByteBuffer +get(int index, byte[] dst, int offset, int length) ByteBuffer +getChar() char +getChar(int index) char +getDouble() double +getDouble(int index) double +getFloat() float +getFloat(int index) float +getInt() int +getInt(int index) int +getLong() long +getLong(int index) long +put(byte b) ByteBuffer +put(byte[] src) ByteBuffer +put(byte[] src, int offset, int length) ByteBuffer +put(int value) ByteBuffer +put(int index, int value) ByteBuffer } ``` --- ## 相关笔记 * [Java 笔记](Java_Note.md) * [Java 基础笔记](Java_Base_Note.md) * [Java 视频清单](Java_Videos.md)