《Java 高级篇》六：I/O 流

Author: ACatSmiling

Since: 2024-10-01

字符编码

字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

编码表的由来：计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。这就是编码表。

常见的编码表：

• ASCII：美国标准信息交换码。用一个字节的 7 位可以表示。

• ISO8859-1：拉丁码表，欧洲码表。用一个字节的 8 位表示。

• GB2312：中国的中文编码表。最多两个字节编码所有字符。

• GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码。

• Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。

• UTF-8：变长的编码方式，可用 1 ~ 4 个字节来表示一个字符。

在 Unicode 出现之前，所有的字符集都是和具体编码方案绑定在一起的，即字符集 ≈ 编码方式，都是直接将字符和最终字节流绑定死了。

• GBK 等双字节编码方式，用最高位是 1 或 0 表示两个字节和一个字节。

• Unicode 不完美，这里就有三个问题，一个是，我们已经知道，英文字母只用一个字节表示就够了，第二个问题是如何才能区别 Unicode 和 ASCII，计算机怎么知道是两个字节表示一个符号，而不是分别表示两个符号呢？第三个，如果和 GBK 等双字节编码方式一样，用最高位是 1 或 0 表示两个字节和一个字节，就少了很多值无法用于表示字符，不够表示所有字符。Unicode 在很长一段时间内无法推广，直到互联网的出现。

• 面向传输的 UTF（UCS Transfer Format）标准出现了，顾名思义，UTF-8 就是每次 8 个位传输数据，而 UTF-16 就是每次 16 个位。这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。

• Unicode 只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的 Unicode 编码是 UTF-8 和 UTF-16。

  

  

计算机中储存的信息都是用二进制数表示的，而能在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。

• 编码规则和解码规则要对应，否则会导致乱码。比如说，按照 A 规则存储，同样按照 A 规则解析，那么就能显示正确的文本符号。反之，按照 A 规则存储，再按照 B 规则解析，就会导致乱码现象。

• 编码： 字符串 ---> 字节数组。

• 解码： 字节数组 ---> 字符串。

• 启示：客户端/浏览器端 <------> 后台（Java，GO，Python，Node.js，php...） <------> 数据库，要求前前后后使用的字符集要统一，都使用 UTF-8，这样才不会乱码。

File 类

路径分隔符

路径分隔符：

• 路径中的每级目录之间用一个路径分隔符隔开。

• 路径分隔符和系统有关：

  • Windows 和 DOS 系统默认使用\来表示。
  • UNIX 和 URL 使用/来表示。

• Java 程序支持跨平台运行，因此路径分隔符要慎用。为了解决这个隐患，File 类提供了一个常量public static final String separator，能够根据操作系统，动态的提供分隔符。

• 示例：

  File file1 = new File("d:\\test\\info.txt");
  File file2 = new File("d:/test/info.txt");
  File file3 = new File("d:" + File.separator + "test" + File.separator + "info.txt");
  

File 定义

java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关。

• File 主要表示类似D:\\文件目录1与D:\\文件目录1\\文件.txt，前者是文件夹（directory），后者则是文件（file），而 File 类就是操作这两者的类。

File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

• File 跟流无关，File 类不能对文件进行读和写，也就是输入和输出。

想要在 Java 程序中表示一个真实存在的文件或目录，那么必须有一个 File 对象，但是 Java 程序中的一个 File 对象，可能不对应一个真实存在的文件或目录。

File 构造方法

File 常用的构造方法：

• public File(String pathname) ：以 pathname 为路径创建 File 对象，可以是绝对路径或者相对路径，如果 pathname 是相对路径，则默认的当前路径在系统属性 user.dir 中存储。

  • 绝对路径：是一个固定的路径，从盘符开始。

  • 相对路径：是相对于某个位置开始。

  • IDEA 中的路径说明，main() 和 Test 中，相对路径不一样：

    public class Test {public static void main(String[] args) {File file = new File("hello.txt");// 相较于当前工程System.out.println(file.getAbsolutePath());// D:\JetBrainsWorkSpace\IDEAProjects\xisun-projects\hello.txt}@Testpublic void testFileReader() {File file = new File("hello.txt");// 相较于当前ModuleSystem.out.println(file.getAbsolutePath());// D:\JetBrainsWorkSpace\IDEAProjects\xisun-projects\xisun-java_base\hello.txt}
    }
    

• public File(String parent, String child) ：以 parent 为父路径，child 为子路径创建 File 对象。

• public File(File parent, String child) ：根据一个父 File 对象和子文件路径创建 File 对象。

File 基础信息

获取 File 基础信息的方法：

• public String getAbsolutePath()：获取绝对路径。

• public String getPath()：获取路径。

• public String getName()：获取名称。

• public String getParent()：获取上层文件目录路径。若无，返回 null。

• public long length()：获取文件长度，即：字节数。不能获取目录的长度。

• public long lastModified()：获取最后一次的修改时间，毫秒值。

• public String[] list()：获取指定目录下的所有文件或者文件目录的名称数组，如果指定目录不存在，返回 null。

• public File[] listFiles()：获取指定目录下的所有文件或者文件目录的 File 数组，如果指定目录不存在，返回 null。

• public String[] list(FilenameFilter filter)：指定文件过滤器。

• public File[] listFiles(FilenameFilter filter)：指定文件过滤器。

• public File[] listFiles(FileFilter filter)：指定文件过滤器。

File 重命名

File 重命名的方法：

• public boolean renameTo(File dest)：把文件重命名为指定的文件路径。以file1.renameTo(file2)为例：要想保证返回 true，需要 file1 在硬盘中是存在的，且 file2 在硬盘中不能存在。

File 判断

判断 File 相关信息的方法：

• public boolean exists()：判断是否存在。

• public boolean isDirectory()：判断是否是文件目录。

• public boolean isFile()：判断是否是文件。

• public boolean canRead()：判断是否可读。

• public boolean canWrite()：判断是否可写。

• public boolean isHidden()：判断是否隐藏。

File 创建

创建 File 的方法：

• public boolean createNewFile()：创建文件。若文件不存在，则创建一个新的空文件并返回 true；若文件存在，则不创建文件并返回 false。
• public boolean mkdir()：创建文件目录。如果此文件目录存在，则不创建；如果此文件目录的上层目录不存在，也不创建。
• public boolean mkdirs()：创建文件目录。如果上层文件目录不存在，也一并创建。
• 如果创建文件或者文件目录时，没有写盘符路径，那么，默认在项目路径下。

File 删除

删除 File 的方法：

• public boolean delete()：删除文件或者文件夹。
• Java 中的删除不走回收站。要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录，即只能删除空的文件目录。

File 遍历

递归遍历文件夹下所有文件以及子文件：

public class Test {public static void main(String[] args) {// 递归：文件目录/** 打印出指定目录所有文件名称，包括子文件目录中的文件 */// 1. 创建目录对象File dir = new File("E:\\teach\\01_javaSE\\_尚硅谷Java编程语言\\3_软件");// 2. 打印目录的子文件printSubFile(dir);}// 方式一：public static void printSubFile(File dir) {// 判断传入的是否是目录if (!dir.isDirectory()) {// 不是目录直接退出return;}// 打印目录的子文件File[] subfiles = dir.listFiles();if (subfiles != null) {for (File f : subfiles) {if (f.isDirectory()) {// 文件目录printSubFile(f);} else {// 文件System.out.println(f.getAbsolutePath());}}}}// 方式二：循环实现// 列出 file 目录的下级内容，仅列出一级的话，使用 File 类的 String[] list() 比较简单public void listSubFiles(File file) {if (file.isDirectory()) {String[] all = file.list();if (all != null) {for (String s : all) {System.out.println(s);}}} else {System.out.println(file + "是文件！");}}// 方式三：列出 file 目录的下级，如果它的下级还是目录，接着列出下级的下级，依次类推// 建议使用 File 类的 File[] listFiles()public void listAllSubFiles(File file) {if (file.isFile()) {System.out.println(file);} else {File[] all = file.listFiles();// 如果 all[i] 是文件，直接打印// 如果 all[i] 是目录，接着再获取它的下一级if (all != null) {for (File f : all) {// 递归调用：自己调用自己就叫递归listAllSubFiles(f);}}}}// 拓展 1：计算指定目录所在空间的大小// 求任意一个目录的总大小public long getDirectorySize(File file) {// file 是文件，那么直接返回 file.length()// file 是目录，把它的下一级的所有大小加起来就是它的总大小long size = 0;if (file.isFile()) {size += file.length();} else {// 获取 file 的下一级File[] all = file.listFiles();if (all != null) {// 累加 all[i] 的大小for (File f : all) {// f 的大小size += getDirectorySize(f);}}}return size;}// 拓展 2：删除指定文件目录及其下的所有文件public void deleteDirectory(File file) {// 如果 file 是文件，直接 delete// 如果 file 是目录，先把它的下一级干掉，然后删除自己if (file.isDirectory()) {File[] all = file.listFiles();// 循环删除的是 file 的下一级if (all != null) {// f 代表 file 的每一个下级for (File f : all) {deleteDirectory(f);}}}// 删除自己file.delete();}
}

NIO.2 中 Path 、Paths 、Files

Java NIO (New IO 或 Non-Blocking IO)是从 Java 1.4 版本开始引入的一套新的 I/O API，可以替代标准的 Java I/O API。NIO 与原来的 I/O 有同样的作用和目的，但是使用的方式完全不同，NIO 支持面向缓冲区的（I/O是面向流的）、基于通道的 I/O 操作，NIO 也会以更加高效的方式进行文件的读写操作。

Java API 中提供了两套 NIO，一套是针对标准输入输出 NIO，另一套就是网络编程 NIO。

• |----- java.nio.channels.Channel
  • |----- FileChannel：处理本地文件。
    • |----- SocketChannel：TCP 网络编程的客户端的 Channel。
    • |----- ServerSocketChannel：TCP 网络编程的服务器端的 Channel。
    • |----- DatagramChannel：UDP 网络编程中发送端和接收端的 Channel。

随着 JDK 7 的发布，Java 对 NIO 进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为 NIO.2。因为 NIO 提供的一些功能，NIO 已经成为文件处理中越来越重要的部分。

早期的 Java 只提供了一个 File 类来访问文件系统，但 File 类的功能比较有限，所提供的方法性能也不高。而且，大多数方法在出错时仅返回失败，并不会提供异常信息。

NIO. 2 为了弥补这种不足，引入了 Path 接口，代表一个平台无关的平台路径，描述了目录结构中文件的位置。Path 可以看成是 File 类的升级版本，实际引用的资源也可以不存在。

在以前 I/O 操作是类似如下写法的：

import java.io.File;File file = new File("index.html");

但在 JDK 7 中，我们可以这样写：

import java.nio.file.Path;
import java.nio.file.Paths;Path path = Paths.get("index.html");

同时，NIO.2 在java.nio.file包下还提供了 Files、Paths 工具类，Files 包含了大量静态的工具方法来操作文件；Paths 则包含了两个返回 Path 的静态工厂方法。

Paths 类提供的获取 Path 对象的方法：

• static Path get(String first, String … more)：用于将多个字符串串连成路径。

• static Path get(URI uri)：返回指定 uri 对应的 Path 路径。

  public class PathTest {/*如何使用Paths实例化Path*/@Testpublic void test1() {Path path1 = Paths.get("d:\\nio\\hello.txt");// = new File(String filepath)System.out.println(path1);Path path2 = Paths.get("d:\\", "nio\\hello.txt");// = new File(String parent,String filename);System.out.println(path2);Path path3 = Paths.get("d:\\", "nio");System.out.println(path3);}
  }
  

Path 类常用方法：

• String toString()：返回调用 Path 对象的字符串表示形式。

• boolean startsWith(String path)：判断是否以 path 路径开始。

• boolean endsWith(String path)：判断是否以 path 路径结束。

• boolean isAbsolute()：判断是否是绝对路径。

• Path getParent()：返回 Path 对象包含整个路径，不包含 Path 对象指定的文件路径。

• Path getRoot()：返回调用 Path 对象的根路径。

• Path getFileName()：返回与调用 Path 对象关联的文件名。

• int getNameCount()：返回 Path 根目录后面元素的数量。

• Path getName(int idx)：返回指定索引位置 idx 的路径名称。

• Path toAbsolutePath()：作为绝对路径返回调用 Path 对象。

• Path resolve(Path p)：合并两个路径，返回合并后的路径对应的 Path 对象。

• File toFile()：将 Path 转化为 File 类的对象。File 类转化为 Path 对象的方法是：Path toPath()。

  public class PathTest {/*Path中的常用方法*/@Testpublic void test2() {Path path1 = Paths.get("d:\\", "nio\\nio1\\nio2\\hello.txt");Path path2 = Paths.get("hello1.txt");// 相对当前Module的路径// String toString()：返回调用Path对象的字符串表示形式System.out.println(path1);// d:\nio\nio1\nio2\hello.txt// boolean startsWith(String path): 判断是否以path路径开始System.out.println(path1.startsWith("d:\\nio"));// true// boolean endsWith(String path): 判断是否以path路径结束System.out.println(path1.endsWith("hello.txt"));// true// boolean isAbsolute(): 判断是否是绝对路径System.out.println(path1.isAbsolute() + "~");// true~System.out.println(path2.isAbsolute() + "~");// false~// Path getParent()：返回Path对象包含整个路径，不包含Path对象指定的文件路径System.out.println(path1.getParent());// d:\nio\nio1\nio2System.out.println(path2.getParent());// null// Path getRoot()：返回调用Path对象的根路径System.out.println(path1.getRoot());// d:\System.out.println(path2.getRoot());// null// Path getFileName(): 返回与调用Path对象关联的文件名System.out.println(path1.getFileName() + "~");// hello.txt~System.out.println(path2.getFileName() + "~");// hello1.txt~// int getNameCount(): 返回Path根目录后面元素的数量// Path getName(int idx): 返回指定索引位置idx的路径名称for (int i = 0; i < path1.getNameCount(); i++) {// nio*****nio1*****nio2*****hello.txt*****System.out.print(path1.getName(i) + "*****");}System.out.println();// Path toAbsolutePath(): 作为绝对路径返回调用Path对象System.out.println(path1.toAbsolutePath());// d:\nio\nio1\nio2\hello.txtSystem.out.println(path2.toAbsolutePath());// D:\xisun-projects\java_base\hello1.txt// Path resolve(Path p): 合并两个路径，返回合并后的路径对应的Path对象Path path3 = Paths.get("d:\\", "nio");Path path4 = Paths.get("nioo\\hi.txt");path3 = path3.resolve(path4);System.out.println(path3);// d:\nio\nioo\hi.txt// File toFile(): 将Path转化为File类的对象File file = path1.toFile();// Path--->File的转换// Path toPath(): 将File转化为Path类的对象Path newPath = file.toPath();// File--->Path的转换}
  }
  

java.nio.file.Files：用于操作文件或目录的工具类。常用方法：

• Path copy(Path src, Path dest, CopyOption … how)：文件的复制。

• Path createDirectory(Path path, FileAttribute<?> … attr)：创建一个目录。

• Path createFile(Path path, FileAttribute<?> … arr)：创建一个文件。

• void delete(Path path)：删除一个文件/目录，如果不存在，执行报错。

• void deleteIfExists(Path path)：Path 对应的文件/目录如果存在，执行删除。

• Path move(Path src, Path dest, CopyOption…how)：将 src 移动到 dest 位置。

• long size(Path path)：返回 path 指定文件的大小。

• boolean exists(Path path, LinkOption … opts)：判断文件是否存在。

• boolean isDirectory(Path path, LinkOption … opts)：判断是否是目录。

• boolean isRegularFile(Path path, LinkOption … opts)：判断是否是文件。

• boolean isHidden(Path path)：判断是否是隐藏文件。

• boolean isReadable(Path path)：判断文件是否可读。

• boolean isWritable(Path path)：判断文件是否可写。

• boolean notExists(Path path, LinkOption … opts)：判断文件是否不存在。

• SeekableByteChannel newByteChannel(Path path, OpenOption…how)：获取与指定文件的连接，how 指定打开方式。

• DirectoryStream\<Path> newDirectoryStream(Path path)：打开 path 指定的目录。

• InputStream newInputStream(Path path, OpenOption…how)：获取 InputStream 对象。

• OutputStream newOutputStream(Path path, OpenOption…how)：获取 OutputStream 对象。

  public class FilesTest {@Testpublic void test1() throws IOException {Path path1 = Paths.get("d:\\nio", "hello.txt");Path path2 = Paths.get("atguigu.txt");// Path copy(Path src, Path dest, CopyOption … how): 文件的复制// 要想复制成功，要求path1对应的物理上的文件存在。path2 对应的文件没有要求。// Files.copy(path1, path2, StandardCopyOption.REPLACE_EXISTING);// Path createDirectory(Path path, FileAttribute<?> … attr): 创建一个目录// 要想执行成功，要求path对应的物理上的文件目录不存在。一旦存在，抛出异常。Path path3 = Paths.get("d:\\nio\\nio1");// Files.createDirectory(path3);// Path createFile(Path path, FileAttribute<?> … arr): 创建一个文件// 要想执行成功，要求path对应的物理上的文件不存在。一旦存在，抛出异常。Path path4 = Paths.get("d:\\nio\\hi.txt");// Files.createFile(path4);// void delete(Path path): 删除一个文件/目录，如果不存在，执行报错// Files.delete(path4);// void deleteIfExists(Path path): Path对应的文件/目录如果存在，执行删除。如果不存在，正常执行结束Files.deleteIfExists(path3);// Path move(Path src, Path dest, CopyOption…how): 将src移动到dest位置// 要想执行成功，src对应的物理上的文件需要存在，dest对应的文件没有要求。// Files.move(path1, path2, StandardCopyOption.ATOMIC_MOVE);// long size(Path path): 返回path指定文件的大小long size = Files.size(path2);System.out.println(size);}@Testpublic void test2() throws IOException {Path path1 = Paths.get("d:\\nio", "hello.txt");Path path2 = Paths.get("atguigu.txt");// boolean exists(Path path, LinkOption … opts): 判断文件是否存在System.out.println(Files.exists(path2, LinkOption.NOFOLLOW_LINKS));// boolean isDirectory(Path path, LinkOption … opts): 判断是否是目录// 不要求此path对应的物理文件存在。System.out.println(Files.isDirectory(path1, LinkOption.NOFOLLOW_LINKS));// boolean isRegularFile(Path path, LinkOption … opts): 判断是否是文件// /boolean isHidden(Path path): 判断是否是隐藏文件// 要求此path对应的物理上的文件需要存在。才可判断是否隐藏。否则，抛异常。System.out.println(Files.isHidden(path1));// /boolean isReadable(Path path): 判断文件是否可读System.out.println(Files.isReadable(path1));// boolean isWritable(Path path): 判断文件是否可写System.out.println(Files.isWritable(path1));// boolean notExists(Path path, LinkOption … opts): 判断文件是否不存在System.out.println(Files.notExists(path1, LinkOption.NOFOLLOW_LINKS));}/*** StandardOpenOption.READ: 表示对应的Channel是可读的。* StandardOpenOption.WRITE：表示对应的Channel是可写的。* StandardOpenOption.CREATE：如果要写出的文件不存在，则创建。如果存在，忽略* StandardOpenOption.CREATE_NEW：如果要写出的文件不存在，则创建。如果存在，抛异常** @throws IOException*/@Testpublic void test3() throws IOException {Path path1 = Paths.get("d:\\nio", "hello.txt");// InputStream newInputStream(Path path, OpenOption…how): 获取InputStream对象InputStream inputStream = Files.newInputStream(path1, StandardOpenOption.READ);// OutputStream newOutputStream(Path path, OpenOption…how): 获取OutputStream对象OutputStream outputStream = Files.newOutputStream(path1, StandardOpenOption.WRITE, StandardOpenOption.CREATE);// SeekableByteChannel newByteChannel(Path path, OpenOption…how): 获取与指定文件的连接，how指定打开方式SeekableByteChannel channel = Files.newByteChannel(path1, StandardOpenOption.READ,StandardOpenOption.WRITE, StandardOpenOption.CREATE);// DirectoryStream<Path>  newDirectoryStream(Path path): 打开path指定的目录Path path2 = Paths.get("e:\\teach");DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path2);Iterator<Path> iterator = directoryStream.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}}
  }
  

FileUtils 工具类

Maven 引入依赖：

<dependency><groupId>commons-io</groupId><artifactId>commons-io</artifactId><version>2.7</version>
</dependency>

复制功能：

public class FileUtilsTest {public static void main(String[] args) {File srcFile = new File("day10\\爱情与友情.jpg");File destFile = new File("day10\\爱情与友情2.jpg");try {FileUtils.copyFile(srcFile, destFile);} catch (IOException e) {e.printStackTrace();}}
}

遍历文件夹和文件的每一行：

public class FileUtilsMethod {/*** 常规方法：若文件路径内的文件比较少，可以采用此方法** @param filePath 文件路径*/public static void common(String filePath) {File file = new File(filePath);if (file.exists()) {// 获取子文件夹内所有文件，放到文件数组里，如果含有大量文件，会创建一个很大的数组，占用空间File[] fileList = file.listFiles();for (File currentFile : fileList) { // 当前文件是普通文件(排除文件夹)，且不是隐藏文件if (currentFile.isFile() && !currentFile.isHidden()) {// 当前文件的完整路径，含文件名String currentFilePath = currentFile.getPath();if (currentFilePath.endsWith("xml") || currentFilePath.endsWith("XML")) {// 当前文件的文件名，含后缀String fileName = currentFile.getName();System.out.println("文件名：" + fileName);}}}System.out.println("=======================================");// list方法返回的是文件名的String数组String[] fileNameList = file.list();for (String fileName : fileNameList) {System.out.println("文件名：" + fileName);}}}/*** 根据文件路径，迭代获取该路径下指定文件后缀类型的文件：若文件路径内含有大量文件，建议采用此方法** @param filePath 文件路径*/public static void iterateFiles(String filePath) {File file = FileUtils.getFile(filePath);if (file.isDirectory()) {Iterator<File> fileIterator = FileUtils.iterateFiles(file, new String[]{"xml", "XML"}, false);while (fileIterator.hasNext()) {File currentFile = fileIterator.next();if (currentFile.isFile() && !currentFile.isHidden()) {// 绝对路径String currentFilePath = currentFile.getAbsolutePath();System.out.println("绝对路径：" + currentFilePath);// 文件名，含文件后缀String fileName = currentFilePath.substring(currentFilePath.lastIndexOf("\\") + 1);System.out.println("含后缀文件名：" + fileName);// 文件名，不含文件后缀fileName = fileName.substring(0, fileName.lastIndexOf("."));System.out.println("不含后缀文件名：" + fileName);}}}}/*** 读取目标文件每一行数据，返回List：若文件内容较少，可以采用此方法** @param filePath 文件路径* @throws IOException*/public static void readLinesForList(String filePath) throws IOException {List<String> linesList = FileUtils.readLines(new File(filePath), "utf-8");for (String line : linesList) {System.out.println(line);}}/*** 读取目标文件每一行数据，返回迭代器：若文件内容较多，建议采用此方法** @param filePath 文件路径* @throws IOException*/public static void readLinesForIterator(String filePath) throws IOException {LineIterator lineIterator = FileUtils.lineIterator(new File(filePath), "utf-8");while (lineIterator.hasNext()) {System.out.println(lineIterator.next());}}
}

I/O 流

I/O 的原理

I/O是 Input/Output 的缩写， I/O 技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。

• Java 程序中，对于数据的输入/输出操作以流 (stream)的方式进行。
• java.io包下提供了各种 "流" 类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

输入 input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。

输出 output：将程序（内存）数据输出到磁盘、光盘等外部存储设备中。

I/O 的分类

按操作数据单位不同分为：字节流（8 bit），字符流（16 bit）。

• 字节流：以字节为单位，读写数据的流。
• 字符流：以字符为单位，读写数据的流。

按数据流的流向不同分为：输入流，输出流。

• 输入流：把数据从其他设备上读取到内存中的流。
• 输出流：把数据从内存中写出到其他设备上的流。

按流的角色的不同分为：节点流，处理流。

• 节点流：直接从数据源或目的地读写数据。也叫文件流。

  

• 处理流：不直接连接到数据源或目的地，而是连接在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

  

Java 的 I/O 流共涉及 40 多个类，实际上非常规则，都是从如下四个抽象基类派生的。同时，由这四个类派生出来的子类名称都是以其父类名作为子类名后缀：

I/O 流体系：

I/O 的四个抽象基类

InputStream & Reader

InputStream 和 Reader 是所有输入流的基类。

• InputStream 的典型实现：FileInputStream。
  • FileInputStream：用于读取非文本数据的原始字节流。
• Reader 的典型实现：FileReader。
  • FileReader：用于读取文本数据的字符流。

InputStream

InputStream 的方法：

• int read()：从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。
• int read(byte[] b)：从输入流中将最多b.length()个字节的数据读入一个 byte 数组中。以整数形式返回实际读取的字节数。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。
• int read(byte[] b, int off,int len)：将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。
• public void close() throws IOException：关闭输入流并释放与该流关联的所有系统资源。

Reader

Reader 的方法：

• int read()：读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间（0x00-0xffff）（2 个字节的 Unicode 码），如果已到达流的末尾，则返回 -1。
• int read(char[] cbuf)：将字符读入数组。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
• int read(char[] cbuf,int off,int len)：将字符读入数组的某一部分。存到数组 cbuf 中，从 off 处开始存储，最多读 len 个字符。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
• public void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。

OutputStream & Writer

OutputStream 和 Writer 是所有输出流的基类。

• OutputStream 的典型实现：FileOutStream。
  • FileOutputStream：用于写出非文本数据的原始字节流。
• Writer 的典型实现：FileWriter。
  • FileWriter：用于写出文本数据的字符流。

OutputStream

OutputStream 的方法：

• void write(int b)：将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略，即写入 0 ~ 255 范围的。
• void write(byte[] b)：将 b.length() 个字节从指定的 byte 数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。
• void write(byte[] b,int off,int len)：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
• public void flush() throws IOException：刷新此输出流并强制写出所有缓冲的输出字节，调用此方法指示应将这些字节立即写入它们预期的目标。
• public void close() throws IOException：关闭此输出流并释放与该流关联的所有系统资源。

Writer

Writer 的方法：

• void write(int c)：写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。 即写入 0 到 65535 之间的 Unicode 码。
• void write(char[] cbuf)：写入字符数组。
• void write(char[] cbuf,int off,int len)：写入字符数组的某一部分。从 off 开始，写入 len 个字符。
• void write(String str)：写入字符串。
• void write(String str,int off,int len)：写入字符串的某一部分。
• public void flush() throws IOException：刷新该流的缓冲，则立即将它们写入预期目标。
• public void close() throws IOException：关闭此输出流并释放与该流关联的所有系统资源。

节点流（或文件流）

读取文件流程：

• 实例化 File 类的对象，指明要操作的文件。
• 提供具体的流对象。
• 数据的读入。
• 流的关闭操作。

写入文件流程：

• 实例化 File 类的对象，指明写出到的文件。
• 提供具体的流对象。
• 数据的写入。
• 流的关闭操作。

注意事项：

• 定义文件路径时，可以用 / 或者 \。
• 在读取文件时，必须保证该文件已存在，否则报异常。
• 对于非文本文件（.jpg，.mp3，.mp4，.avi，.rmvb，.doc，.ppt 等），使用字节流处理。如果使用字节流操作文本文件，在输出到控制台时，可能会出现乱码。
• 对于文本文件（.txt，.java，.c，.cpp 等），使用字符流处理。

FileInputStream 和 FileOutputStream

在写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文件将被覆盖。如果使用构造器FileOutputStream(file,true)，则目录下的同名文件不会被覆盖，而是在文件内容末尾追加内容。

/*** 测试FileInputStream和FileOutputStream的使用** 结论：* 1. 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理* 2. 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,...)，使用字节流处理*/
public class FileInputOutputStreamTest {/*使用字节流FileInputStream处理文本文件，可能出现乱码。*/@Testpublic void testFileInputStream() {FileInputStream fis = null;try {// 1. 造文件File file = new File("hello.txt");// 2.造流fis = new FileInputStream(file);// 3.读数据byte[] buffer = new byte[5];// 记录每次读取的字节的个数int len;while ((len = fis.read(buffer)) != -1) {String str = new String(buffer, 0, len);System.out.print(str);}} catch (IOException e) {e.printStackTrace();} finally {if (fis != null) {// 4.关闭资源try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}/*实现对图片的复制操作*/@Testpublic void testFileInputOutputStream() {FileInputStream fis = null;FileOutputStream fos = null;try {// 1.获取文件File srcFile = new File("爱情与友情.jpg");File destFile = new File("爱情与友情2.jpg");// 2.获取流fis = new FileInputStream(srcFile);fos = new FileOutputStream(destFile);// 3.复制的过程byte[] buffer = new byte[5];int len;while ((len = fis.read(buffer)) != -1) {fos.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {// 4.关闭流if (fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}/*指定路径下文件的复制*/public void copyFile(String srcPath, String destPath) {FileInputStream fis = null;FileOutputStream fos = null;try {// 1.获取文件File srcFile = new File(srcPath);File destFile = new File(destPath);// 2.获取流fis = new FileInputStream(srcFile);fos = new FileOutputStream(destFile);// 3.复制的过程byte[] buffer = new byte[1024];int len;while ((len = fis.read(buffer)) != -1) {fos.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {// 4.关闭流if (fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}@Testpublic void testCopyFile() {long start = System.currentTimeMillis();String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";String destPath = "C:\\Users\\Administrator\\Desktop\\02-视频.avi";/*String srcPath = "hello.txt";String destPath = "hello3.txt";*/copyFile(srcPath, destPath);long end = System.currentTimeMillis();System.out.println("复制操作花费的时间为：" + (end - start));// 618}
}

FileReader 和 FileWriter

/*** 一、流的分类：* 1.操作数据单位：字节流、字符流* 2.数据的流向：输入流、输出流* 3.流的角色：节点流、处理流** 二、流的体系结构* 抽象基类       节点流（或文件流）                                缓冲流（处理流的一种）* InputStream   FileInputStream   (read(byte[] buffer))        BufferedInputStream (read(byte[] buffer))* OutputStream  FileOutputStream  (write(byte[] buffer,0,len)  BufferedOutputStream (write(byte[] buffer,0,len)/flush()* Reader        FileReader (read(char[] cbuf))                 BufferedReader (read(char[] cbuf)/readLine())* Writer        FileWriter (write(char[] cbuf,0,len)           BufferedWriter (write(char[] cbuf,0,len)/flush()*/
public class FileReaderWriterTest {/*将当前Module下的hello.txt文件内容读入程序中，并输出到控制台说明点：1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-12. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理3. 读入的文件一定要存在，否则就会报FileNotFoundException。*/// read(): 返回读入的一个字符。如果达到文件末尾，返回-1@Testpublic void testFileReader() {FileReader fr = null;try {// 1.实例化File类的对象，指明要操作的文件File file = new File("hello.txt");// 相较于当前Module// 2.提供具体的流fr = new FileReader(file);// 3.数据的读入// 方式一：/*int data = fr.read();while (data != -1) {System.out.print((char) data);data = fr.read();}*/// 方式二：语法上针对于方式一的修改int data;while ((data = fr.read()) != -1) {System.out.print((char) data);}} catch (IOException e) {e.printStackTrace();} finally {// 4.流的关闭操作// 方式一：/*try {if (fr != null)fr.close();} catch (IOException e) {e.printStackTrace();}*/// 方式二：if (fr != null) {try {fr.close();} catch (IOException e) {e.printStackTrace();}}}}// 对read()操作升级：使用read的重载方法read(char[] cbuf)@Testpublic void testFileReader1() {FileReader fr = null;try {// 1.File类的实例化File file = new File("hello.txt");// 2.FileReader流的实例化fr = new FileReader(file);// 3.读入的操作// read(char[] cbuf)：返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1char[] cbuf = new char[5];int len;while ((len = fr.read(cbuf)) != -1) {// 方式一：// 错误的写法，如果以cubf的length为基准，可能会造成多输出内容/*for (int i = 0; i < cbuf.length; i++) {System.out.print(cbuf[i]);}*/// 正确的写法/*for (int i = 0; i < len; i++) {System.out.print(cbuf[i]);}*///方式二：// 错误的写法，对应着方式一的错误的写法/*String str = new String(cbuf);System.out.print(str);*/// 正确的写法，对应着方式一的正确的写法String str = new String(cbuf, 0, len);System.out.print(str);}} catch (IOException e) {e.printStackTrace();} finally {if (fr != null) {// 4.资源的关闭try {fr.close();} catch (IOException e) {e.printStackTrace();}}}}/*从内存中写出数据到硬盘的文件里。说明：1. 输出操作，对应的File可以不存在的。并不会报异常2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。File对应的硬盘中的文件如果存在：如果流使用的构造器是：FileWriter(file,false) / FileWriter(file)--->对原有文件的覆盖如果流使用的构造器是：FileWriter(file,true)--->不会对原有文件覆盖，而是在原有文件基础上追加内容*/@Testpublic void testFileWriter() {FileWriter fw = null;try {// 1.提供File类的对象，指明写出到的文件File file = new File("hello1.txt");// 2.提供FileWriter的对象，用于数据的写出fw = new FileWriter(file, false);// 3.写出的操作fw.write("I have a dream!\n");fw.write("you need to have a dream!");} catch (IOException e) {e.printStackTrace();} finally {// 4.流资源的关闭if (fw != null) {try {fw.close();} catch (IOException e) {e.printStackTrace();}}}}/*实现对已存在文件的复制*/@Testpublic void testFileReaderFileWriter() {FileReader fr = null;FileWriter fw = null;try {// 1.创建File类的对象，指明读入和写出的文件File srcFile = new File("hello.txt");File destFile = new File("hello2.txt");// 不能使用字符流来处理图片等字节数据/*File srcFile = new File("爱情与友情.jpg");File destFile = new File("爱情与友情1.jpg");*/// 2.创建输入流和输出流的对象fr = new FileReader(srcFile);fw = new FileWriter(destFile);// 3.数据的读入和写出操作char[] cbuf = new char[5];// 记录每次读入到cbuf数组中的字符的个数int len;while ((len = fr.read(cbuf)) != -1) {// 每次写出len个字符fw.write(cbuf, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {// 4.关闭流资源// 方式一：/*try {if (fw != null)fw.close();} catch (IOException e) {e.printStackTrace();} finally {try {if (fr != null)fr.close();} catch (IOException e) {e.printStackTrace();}}*/// 方式二：try {if (fw != null)fw.close();} catch (IOException e) {e.printStackTrace();}try {if (fr != null)fr.close();} catch (IOException e) {e.printStackTrace();}}}
}

处理流

缓冲流

为了提高数据读写的速度，Java API 提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用 8192 个字节 (8Kb) 的缓冲区。

public class BufferedInputStream extends FilterInputStream {private static int DEFAULT_BUFFER_SIZE = 8192;
}

public class BufferedReader extends Reader {private static int defaultCharBufferSize = 8192;
}

public class BufferedWriter extends Writer {private static int defaultCharBufferSize = 8192;
}

缓冲流要 "套接" 在相应的节点流之上，根据数据操作单位可以把缓冲流分为：

• BufferedInputStream和BufferedOutputStream
  • public BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流，注意参数类型为 InputStream。
  • public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流，注意参数类型为 OutputStream。
• BufferedReader和BufferedWriter
  • public BufferedReader(Reader in) ：创建一个新的缓冲输入流，注意参数类型为 Reader。
  • public BufferedWriter(Writer out)： 创建一个新的缓冲输出流，注意参数类型为 Writer。

当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区。

当使用 BufferedInputStream 读取字节文件时，BufferedInputStream 会一次性从文件中读取 8192 个字节（8Kb）存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个 8192 个字节数组。

向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，BufferedOutputStream 才会把缓冲区中的数据一次性写到文件里。使用flush()可以强制将缓冲区的内容全部写入输出流。

• flush()的使用：手动将 buffer 中内容写入文件。
• 如果使用带缓冲区的流对象的close()，不但会关闭流，还会在关闭流之前刷新缓冲区，但关闭流后不能再写出。

关闭流的顺序和打开流的顺序相反。一般只需关闭最外层流即可，关闭最外层流也会相应关闭内层节点流。

流程示意图：

实现非文本文件及文本文件的复制：

/*** 处理流之一：缓冲流的使用** 1.缓冲流：* BufferedInputStream* BufferedOutputStream* BufferedReader* BufferedWriter** 2.作用：提高流的读取、写入的速度*   提高读写速度的原因：内部提供了一个缓冲区** 3. 处理流，就是"套接"在已有的流的基础上。(不一定必须是套接在节点流之上)*/
public class BufferedStreamTest {/*使用BufferedInputStream和BufferedOutputStream实现非文本文件的复制*/@Testpublic void BufferedStreamTest() throws FileNotFoundException {BufferedInputStream bis = null;BufferedOutputStream bos = null;try {// 1.造文件File srcFile = new File("爱情与友情.jpg");File destFile = new File("爱情与友情3.jpg");// 2.造流// 2.1 造节点流FileInputStream fis = new FileInputStream((srcFile));FileOutputStream fos = new FileOutputStream(destFile);// 2.2 造缓冲流bis = new BufferedInputStream(fis);bos = new BufferedOutputStream(fos);// 3.复制的细节：读取、写入byte[] buffer = new byte[10];int len;while ((len = bis.read(buffer)) != -1) {bos.write(buffer, 0, len);// bos.flush();// 显示的刷新缓冲区，一般不需要}} catch (IOException e) {e.printStackTrace();} finally {// 4.资源关闭// 要求：先关闭外层的流，再关闭内层的流if (bos != null) {try {bos.close();} catch (IOException e) {e.printStackTrace();}}if (bis != null) {try {bis.close();} catch (IOException e) {e.printStackTrace();}}// 说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.// fos.close();// fis.close();}}/*使用BufferedInputStream和BufferedOutputStream实现文件复制的方法*/public void copyFileWithBuffered(String srcPath, String destPath) {BufferedInputStream bis = null;BufferedOutputStream bos = null;try {// 1.造文件File srcFile = new File(srcPath);File destFile = new File(destPath);// 2.造流// 2.1 造节点流FileInputStream fis = new FileInputStream((srcFile));FileOutputStream fos = new FileOutputStream(destFile);// 2.2 造缓冲流bis = new BufferedInputStream(fis);bos = new BufferedOutputStream(fos);// 3.复制的细节：读取、写入byte[] buffer = new byte[1024];int len;while ((len = bis.read(buffer)) != -1) {bos.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {// 4.资源关闭// 要求：先关闭外层的流，再关闭内层的流if (bos != null) {try {bos.close();} catch (IOException e) {e.printStackTrace();}}if (bis != null) {try {bis.close();} catch (IOException e) {e.printStackTrace();}}// 说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.// fos.close();// fis.close();}}@Testpublic void testCopyFileWithBuffered() {long start = System.currentTimeMillis();String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";String destPath = "C:\\Users\\Administrator\\Desktop\\03-视频.avi";copyFileWithBuffered(srcPath, destPath);long end = System.currentTimeMillis();System.out.println("复制操作花费的时间为：" + (end - start));//618 - 176}/*使用BufferedReader和BufferedWriter实现文本文件的复制*/@Testpublic void testBufferedReaderBufferedWriter() {BufferedReader br = null;BufferedWriter bw = null;try {// 1.创建文件和相应的流br = new BufferedReader(new FileReader(new File("dbcp.txt")));bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));// 2.读写操作// 方式一：使用char[]数组/*char[] cbuf = new char[1024];int len;while ((len = br.read(cbuf)) != -1) {// 读到文件末尾时返回-1bw.write(cbuf, 0, len);// bw.flush();}*/// 方式二：使用StringString data;while ((data = br.readLine()) != null) {// 读到文件末尾时返回null// 方法一：// bw.write(data + "\n");// data中不包含换行符// 方法二：bw.write(data);// data中不包含换行符bw.newLine();// 提供换行的操作}} catch (IOException e) {e.printStackTrace();} finally {// 3.关闭资源if (bw != null) {try {bw.close();} catch (IOException e) {e.printStackTrace();}}if (br != null) {try {br.close();} catch (IOException e) {e.printStackTrace();}}}}
}

实现图片加密：

public class ImageEncryption {/*图片的加密*/@Testpublic void test1() {FileInputStream fis = null;FileOutputStream fos = null;try {fis = new FileInputStream("爱情与友情.jpg");fos = new FileOutputStream("爱情与友情secret.jpg");byte[] buffer = new byte[20];int len;while ((len = fis.read(buffer)) != -1) {// 加密：对字节数组进行修改，异或操作// 错误的写法，buffer数组中的数据没有改变，只是重新复制给了变量b/*for (byte b : buffer) {b = (byte) (b ^ 5);}*/// 正确的写法for (int i = 0; i < len; i++) {buffer[i] = (byte) (buffer[i] ^ 5);}fos.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {if (fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}/*图片的解密*/@Testpublic void test2() {FileInputStream fis = null;FileOutputStream fos = null;try {fis = new FileInputStream("爱情与友情secret.jpg");fos = new FileOutputStream("爱情与友情4.jpg");byte[] buffer = new byte[20];int len;while ((len = fis.read(buffer)) != -1) {// 解密：对字节数组进行修改，异或操作之后再异或，返回的是自己本身// 错误的写法/*for (byte b : buffer) {b = (byte) (b ^ 5);}*/// 正确的写法for (int i = 0; i < len; i++) {buffer[i] = (byte) (buffer[i] ^ 5);}fos.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {if (fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

获取文本上每个字符出现的次数：

public class WordCount {/*说明：如果使用单元测试，文件相对路径为当前module如果使用main()测试，文件相对路径为当前工程*/@Testpublic void testWordCount() {FileReader fr = null;BufferedWriter bw = null;try {// 1.创建Map集合Map<Character, Integer> map = new HashMap<Character, Integer>();// 2.遍历每一个字符，每一个字符出现的次数放到map中fr = new FileReader("dbcp.txt");int c;while ((c = fr.read()) != -1) {// int 还原 charchar ch = (char) c;// 判断char是否在map中第一次出现if (map.get(ch) == null) {map.put(ch, 1);} else {map.put(ch, map.get(ch) + 1);}}// 3.把map中数据存在文件count.txt// 3.1 创建Writerbw = new BufferedWriter(new FileWriter("wordcount.txt"));// 3.2 遍历map，再写入数据Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();for (Map.Entry<Character, Integer> entry : entrySet) {switch (entry.getKey()) {case ' ':bw.write("空格 = " + entry.getValue());break;case '\t'://\t表示tab 键字符bw.write("tab键 = " + entry.getValue());break;case '\r'://bw.write("回车 = " + entry.getValue());break;case '\n'://bw.write("换行 = " + entry.getValue());break;default:bw.write(entry.getKey() + " = " + entry.getValue());break;}bw.newLine();}} catch (IOException e) {e.printStackTrace();} finally {// 4.关闭流if (fr != null) {try {fr.close();} catch (IOException e) {e.printStackTrace();}}if (bw != null) {try {bw.close();} catch (IOException e) {e.printStackTrace();}}}}
}

转换流

转换流提供了在字节流和字符流之间的转换。

• 字节流中的数据都是字符时，转成字符流操作更高效。
• 很多时候我们使用转换流来处理文件乱码问题，实现编码和解码的功能。

Java API 提供了两个转换流：

• InputStreamReader：将 InputStream 转换为 Reader。
  • InputStreamReader(InputStream in)：创建一个使用默认字符集的字符流。
  • InputStreamReader(InputStream in, String charsetName)：创建一个指定字符集的字符流。
• OutputStreamWriter：将 Writer 转换为 OutputStream。
  • OutputStreamWriter(OutputStream in)：创建一个使用默认字符集的字符流。
  • OutputStreamWriter(OutputStream in, String charsetName)：创建一个指定字符集的字符流。

InputStreamReader：

• 实现将字节的输入流按指定字符集转换为字符的输入流。
• 需要和 InputStream 套接。
• 构造器
  • public InputStreamReader(InputStream in)
  • public InputSreamReader(InputStream in,String charsetName)
    • 比如：Reader isr = new InputStreamReader(System.in,"gbk");，指定字符集为 gbk。

OutputStreamWriter：

• 实现将字符的输出流按指定字符集转换为字节的输出流。
• 需要和 OutputStream 套接。
• 构造器
  • public OutputStreamWriter(OutputStream out)
  • public OutputSreamWriter(OutputStream out,String charsetName)

使用 InputStreamReader 解码时，使用的字符集取决于 OutputStreamWriter 编码时使用的字符集。

流程示意图：

转换流的编码应用：

• 可以将字符按指定编码格式存储。
• 可以对文本数据按指定编码格式来解读。
• 指定编码表的动作由构造器完成。

为了达到最高效率，可以考虑在 BufferedReader 内包装 InputStreamReader：

BufferedReader in = new BufferedReader(new InputStreamReader(System.in))；

示例：

/*** 处理流之二：转换流的使用* 1.转换流：属于字符流*   InputStreamReader：将一个字节的输入流转换为字符的输入流*   OutputStreamWriter：将一个字符的输出流转换为字节的输出流** 2.作用：提供字节流与字符流之间的转换** 3. 解码：字节、字节数组  --->字符数组、字符串*    编码：字符数组、字符串 ---> 字节、字节数组*** 4.字符集* ASCII：美国标准信息交换码。*   用一个字节的7位可以表示。* ISO8859-1：拉丁码表。欧洲码表*   用一个字节的8位表示。* GB2312：中国的中文编码表。最多两个字节编码所有字符* GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码* Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。* UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。*/
public class InputStreamReaderTest {/*此时处理异常的话，仍然应该使用try-catch-finallyInputStreamReader的使用，实现字节的输入流到字符的输入流的转换*/@Testpublic void test1() {InputStreamReader isr = null;try {FileInputStream fis = new FileInputStream("dbcp.txt");// InputStreamReader isr = new InputStreamReader(fis);// 使用系统默认的字符集，如果在IDEA中，就是看IDEA设置的默认字符集// 参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集isr = new InputStreamReader(fis, StandardCharsets.UTF_8);// 指定字符集char[] cbuf = new char[20];int len;while ((len = isr.read(cbuf)) != -1) {String str = new String(cbuf, 0, len);System.out.print(str);}} catch (IOException exception) {exception.printStackTrace();} finally {if (isr != null) {try {isr.close();} catch (IOException exception) {exception.printStackTrace();}}}}/*此时处理异常的话，仍然应该使用try-catch-finally综合使用InputStreamReader和OutputStreamWriter*/@Testpublic void test2() {InputStreamReader isr = null;OutputStreamWriter osw = null;try {// 1.造文件、造流File file1 = new File("dbcp.txt");File file2 = new File("dbcp_gbk.txt");FileInputStream fis = new FileInputStream(file1);FileOutputStream fos = new FileOutputStream(file2);isr = new InputStreamReader(fis, StandardCharsets.UTF_8);osw = new OutputStreamWriter(fos, "gbk");// 2.读写过程char[] cbuf = new char[20];int len;while ((len = isr.read(cbuf)) != -1) {osw.write(cbuf, 0, len);}} catch (IOException exception) {exception.printStackTrace();} finally {// 3.关闭资源if (isr != null) {try {isr.close();} catch (IOException exception) {exception.printStackTrace();}}if (osw != null) {try {osw.close();} catch (IOException exception) {exception.printStackTrace();}}}}
}

标准输入、输出流

System.in和System.out分别代表了系统标准的输入和输出设备。

• 默认输入设备是：键盘，输出设备是：显示器。

• System.in的类型是 InputStream。

• System.out的类型是 PrintStream，其是 OutputStream 的子类 FilterOutputStream 的子类。

重定向：通过 System 类的setIn()和setOut()对默认设备进行改变。

• public static void setIn(InputStream in)
• public static void setOut(PrintStream out)

示例：

public class OtherStreamTest {/*1.标准的输入、输出流1.1System.in: 标准的输入流，默认从键盘输入System.out: 标准的输出流，默认从控制台输出1.2System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流。1.3练习：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。方法一：使用Scanner实现，调用next()返回一个字符串方法二：使用System.in实现。System.in  --->  转换流 ---> BufferedReader的readLine()*/// IDEA的单元测试不支持从键盘输入，更改为main()public static void main(String[] args) {BufferedReader br = null;try {InputStreamReader isr = new InputStreamReader(System.in);br = new BufferedReader(isr);while (true) {System.out.println("请输入字符串：");String data = br.readLine();if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {System.out.println("程序结束");break;}String upperCase = data.toUpperCase();System.out.println(upperCase);}} catch (IOException e) {e.printStackTrace();} finally {if (br != null) {try {br.close();} catch (IOException e) {e.printStackTrace();}}}}
}

模拟 Scanner：

/*** MyInput.java: Contain the methods for reading int, double, float, boolean, short, byte and* string values from the keyboard*/
public class MyInput {// Read a string from the keyboardpublic static String readString() {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));// Declare and initialize the stringString string = "";// Get the string from the keyboardtry {string = br.readLine();} catch (IOException ex) {System.out.println(ex);}// Return the string obtained from the keyboardreturn string;}// Read an int value from the keyboardpublic static int readInt() {return Integer.parseInt(readString());}// Read a double value from the keyboardpublic static double readDouble() {return Double.parseDouble(readString());}// Read a byte value from the keyboardpublic static double readByte() {return Byte.parseByte(readString());}// Read a short value from the keyboardpublic static double readShort() {return Short.parseShort(readString());}// Read a long value from the keyboardpublic static double readLong() {return Long.parseLong(readString());}// Read a float value from the keyboardpublic static double readFloat() {return Float.parseFloat(readString());}public static void main(String[] args) {int i = readInt();System.out.println("输出的数为：" + i);}
}

打印流

实现将基本数据类型的数据格式转化为字符串输出。

打印流：PrintStream和PrintWriter。

• 提供了一系列重载的print()和println()，用于多种数据类型的输出。
• PrintStream 和 PrintWriter 的输出不会抛出 IOException 异常。
• PrintStream 和 PrintWriter 有自动 flush 功能。
• PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
• System.out 返回的是 PrintStream 的实例。

把标准输出流（控制台输出）改成文件：

public class OtherStreamTest {/*2. 打印流：PrintStream 和PrintWriter2.1 提供了一系列重载的print()和println()2.2 练习：将ASCII字符输出到自定义的外部文件*/@Testpublic void test2() {PrintStream ps = null;try {FileOutputStream fos = new FileOutputStream(new File("D:\\text.txt"));// 创建打印输出流，设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)ps = new PrintStream(fos, true);// 把标准输出流(控制台输出)改成输出到本地文件if (ps != null) {// 如果不设置，下面的循环输出是在控制台// 设置之后，控制台不再输出，而是输出到D:\text.txtSystem.setOut(ps);}// 开始输出ASCII字符for (int i = 0; i <= 255; i++) {System.out.print((char) i);if (i % 50 == 0) {// 每50个数据一行System.out.println();// 换行}}} catch (FileNotFoundException e) {e.printStackTrace();} finally {if (ps != null) {ps.close();}}}
}

数据流

为了方便地操作 Java 语言的基本数据类型和 String 类型的数据，可以使用数据流。（不能操作内存中的对象）

数据流有两个类：分别用于读取和写出基本数据类型、String类的数据。

• DataInputStream和DataOutputStream。
• 分别套接在 InputStream 和 和 OutputStream 子类的流上。
• 用 DataOutputStream 输出的文件需要用 DataInputStream 来读取。
• DataInputStream 读取不同类型的数据的顺序，要与当初 DataOutputStream 写入文件时，保存的数据的顺序一致。

DataInputStream 中的方法：

• boolean readBoolean()，byte readByte()
• char readChar()，float readFloat()
• double readDouble()，short readShort()
• long readLong()，int readInt()
• String readUTF()，void readFully(byte[] b)

DataOutputStream 中的方法：

• 将上述的方法的 read 改为相应的 write 即可。

将内存中的字符串、基本数据类型的变量写出到文件中，再读取到内存中：

public class OtherStreamTest {/*3. 数据流3.1 DataInputStream 和 DataOutputStream3.2 作用：用于读取或写出基本数据类型的变量或字符串练习：将内存中的字符串、基本数据类型的变量写出到文件中。注意：处理异常的话，仍然应该使用try-catch-finally。*/@Testpublic void test3() {DataOutputStream dos = null;try {// 1.造流dos = new DataOutputStream(new FileOutputStream("data.txt"));// 2.写入操作dos.writeUTF("刘建辰");// 写入Stringdos.flush();// 刷新操作，将内存中的数据立即写入文件，也可以在关闭流时自动刷新dos.writeInt(23);// 写入intdos.flush();dos.writeBoolean(true);// 写入booleandos.flush();} catch (IOException exception) {exception.printStackTrace();} finally {// 3.关闭流if (dos != null) {try {dos.close();} catch (IOException exception) {exception.printStackTrace();}}}}/*将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！*/@Testpublic void test4() {DataInputStream dis = null;try {// 1.造流dis = new DataInputStream(new FileInputStream("data.txt"));// 2.读取操作String name = dis.readUTF();// 读取Stringint age = dis.readInt();// 读取intboolean isMale = dis.readBoolean();// 读取booleanSystem.out.println("name = " + name);System.out.println("age = " + age);System.out.println("isMale = " + isMale);} catch (IOException exception) {exception.printStackTrace();} finally {// 3.关闭流if (dis!=null) {try {dis.close();} catch (IOException exception) {exception.printStackTrace();}}}}
}

对象流

ObjectInputStream和OjbectOutputSteam：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把 Java 中的对象写入到数据源中，也能把对象从数据源中还原回来。

• 一般情况下，会把对象转换为 Json 字符串，然后进行序列化和反序列化操作，而不是直接操作对象。

序列化：用 ObjectOutputStream 类保存基本类型数据或对象的机制。

反序列化：用 ObjectInputStream 类读取基本类型数据或对象的机制。

ObjectOutputStream 和 ObjectInputStream 不能序列化 static 和 transient 修饰的成员变量。

• 在序列化一个类的对象时，如果类中含有 static 和 transient 修饰的成员变量，则在反序列化时，这些成员变量的值会变成默认值，而不是序列化时这个对象赋予的值。比如，Person 类含有一个 static 修饰的 String name 属性，序列化时，对象把 name 赋值为张三，在反序列化时，name 会变为 null。

  

对象序列化机制允许把内存中的 Java 对象转换成平台无关的二进制流（序列化操作），从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的 Java 对象（反序列化操作）。

• 序列化的好处在于可将任何实现了 Serializable 接口的对象转化为字节数据，使其在保存和传输时可被还原。

• 序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础，因此序列化机制是 JavaEE 平台的基础。

• 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出 NotSerializableException 异常。

  • Serializable
  • Externalizable

• 凡是实现 Serializable 接口的类都有一个表示序列化版本标识符的静态变量：

  • private static final long serialVersionUID;
  • serialVersionUID 用来表明类的不同版本间的兼容性。 简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
  • 如果类没有显示定义这个静态常量，它的值是 Java 运行时环境根据类的内部细节自动生成的。此时，若类的实例变量做了修改，serialVersionUID 可能发生变化，则再对修改之前被序列化的类进行反序列化操作时，会操作失败。因此，建议显式声明 serialVersionUID。
    • 在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的 serialVersionUID；在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的 serialVersionUID。
    • 当序列化了一个类实例后，后续可能更改一个字段或添加一个字段。如果不设置 serialVersionUID，所做的任何更改都将导致无法反序化旧有实例，并在反序列化时抛出一个异常；如果你添加了 serialVersionUID，在反序列旧有实例时，新添加或更改的字段值将设为初始化值（对象为 null，基本类型为相应的初始默认值），字段被删除将不设置。

简单来说，Java 的序列化机制是通过在运行时判断类的 serialVersionUID 来验证版本一致性的。在进行反序列化时，JVM 会把传来的字节流中的 serialVersionUID 与本地相应实体类的 serialVersionUID 进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即 InvalidCastException。

若某个类实现了 Serializable 接口，该类的对象就是可序列化的：

• 创建一个 ObjectOutputStream。
  • public ObjectOutputStream(OutputStream out)： 创建一个指定 OutputStream 的 ObjectOutputStream。
• 调用 ObjectOutputStream 对象的writeObject(Object obj)输出可序列化对象。
• 注意写出一次，操作flush()一次。

反序列化：

• 创建一个 ObjectInputStream。
  • public ObjectInputStream(InputStream in)： 创建一个指定 InputStream 的 ObjectInputStream。
• 调用readObject()读取流中的对象。

强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的 Field 的类也不能序列化。

• 默认情况下，基本数据类型是可序列化的。String 实现了 Serializable 接口。

流程示意图：

示例：

/*** Person需要满足如下的要求，方可序列化* 1.需要实现接口：Serializable* 2.当前类提供一个全局常量：serialVersionUID* 3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性*   也必须是可序列化的。（默认情况下，基本数据类型可序列化）** 补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量*/
public class Person implements Serializable {public static final long serialVersionUID = 475463534532L;private String name;private int age;private int id;private Account acct;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}public Person(String name, int age, int id) {this.name = name;this.age = age;this.id = id;}public Person(String name, int age, int id, Account acct) {this.name = name;this.age = age;this.id = id;this.acct = acct;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +", id=" + id +", acct=" + acct +'}';}public int getId() {return id;}public void setId(int id) {this.id = id;}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 Account implements Serializable {public static final long serialVersionUID = 4754534532L;private double balance;public Account(double balance) {this.balance = balance;}@Overridepublic String toString() {return "Account{" +"balance=" + balance +'}';}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}
}

/*** 对象流的使用* 1.ObjectInputStream 和 ObjectOutputStream* 2.作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。** 3.要想一个java对象是可序列化的，需要满足相应的要求。见Person.java** 4.序列化机制：* 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种* 二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。* 当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。*/
public class ObjectInputOutputStreamTest {/*序列化过程：将内存中的Java对象保存到磁盘中或通过网络传输出去使用ObjectOutputStream实现*/@Testpublic void testObjectOutputStream() {ObjectOutputStream oos = null;try {// 1.造流oos = new ObjectOutputStream(new FileOutputStream("object.dat"));// 2.序列化：写操作oos.writeObject(new String("我爱北京天安门"));oos.flush();// 刷新操作oos.writeObject(new Person("王铭", 23));oos.flush();oos.writeObject(new Person("张学", 23, 1001, new Account(5000)));oos.flush();} catch (IOException e) {e.printStackTrace();} finally {if (oos != null) {// 3.关闭流try {oos.close();} catch (IOException e) {e.printStackTrace();}}}}/*反序列化：将磁盘文件中的对象还原为内存中的一个Java对象使用ObjectInputStream来实现*/@Testpublic void testObjectInputStream() {ObjectInputStream ois = null;try {// 1.造流ois = new ObjectInputStream(new FileInputStream("object.dat"));// 2.反序列化：读操作// 文件中保存的是不同类型的对象，反序列化时，需要与序列化时的顺序一致Object obj = ois.readObject();String str = (String) obj;System.out.println(str);Person p = (Person) ois.readObject();System.out.println(p);Person p1 = (Person) ois.readObject();System.out.println(p1);} catch (IOException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();} finally {if (ois != null) {try {ois.close();} catch (IOException e) {e.printStackTrace();}}}}
}

面试题：谈谈你对java.io.Serializable接口的理解，我们知道它用于序列化，是空方法接口，还有其它认识吗？

• 实现了 Serializable 接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。 这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说，可以先在 Windows 机器上创建一个对象，对其序列化，然后通过网络发给一台 Unix 机器，然后在那里准确无误地重新 "装配"。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。
• 由于大部分作为参数的类如 String 、Integer 等都实现了java.io.Serializable接口，也可以利用多态的性质，作为参数使接口更灵活。

随机存取文件流

RandomAccessFile声明在java.io包下，但直接继承于java.lang.Object类。并且它实现了 DataInput、DataOutput 这两个接口，也就意味着这个类既可以读也可以写。

RandomAccessFile 类支持随机访问的方式，程序可以直接跳到文件的任意地方来读、写文件。

• 支持只访问文件的部分内容。
• 可以向已存在的文件后追加内容。

RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。RandomAccessFile 类对象可以自由移动记录指针：

• long getFilePointer()：获取文件记录指针的当前位置。
• void seek(long pos)：将文件记录指针定位到 pos 位置。

构造器：

• public RandomAccessFile(File file, String mode)
• public RandomAccessFile(String name, String mode)

创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：

• r：以只读方式打开。

• rw：打开以便读取和写入。

• rwd：打开以便读取和写入；同步文件内容的更新。

• rws：打开以便读取和写入；同步文件内容和元数据的更新。

• JDK 1.6 上面写的每次 write 数据时，rw 模式，数据不会立即写到硬盘中，而 rwd 模式，数据会被立即写入硬盘。如果写数据过程发生异常，rwd 模式中已被 write 的数据会被保存到硬盘，而 rw 模式的数据会全部丢失。

• 如果模式为只读 r，则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常。 如果模式为读写 rw，如果文件不存在则会去创建文件，如果存在则不会创建。

RandomAccessFile 的应用：我们可以用 RandomAccessFile 这个类，来实现一个多线程断点下载的功能，用过下载工具的朋友们都知道，下载前都会建立两个临时文件，一个是与被下载文件大小相同的空文件，另一个是记录文件指针的位置文件，每次暂停的时候，都会保存上一次的指针，然后断点下载的时候，会继续从上一次的地方下载，从而实现断点下载或上传的功能，有兴趣的朋友们可以自己实现下。

示例：

/*** RandomAccessFile的使用* 1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口* 2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流** 3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。*   如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖）** 4. 可以通过相关的操作，实现RandomAccessFile“插入”数据的效果*/
public class RandomAccessFileTest {/*使用RandomAccessFile实现文件的复制*/@Testpublic void test1() {RandomAccessFile raf1 = null;RandomAccessFile raf2 = null;try {// 1.造流raf1 = new RandomAccessFile(new File("爱情与友情.jpg"), "r");raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"), "rw");// 2.读写操作byte[] buffer = new byte[1024];int len;while ((len = raf1.read(buffer)) != -1) {raf2.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {// 3.关闭流if (raf1 != null) {try {raf1.close();} catch (IOException e) {e.printStackTrace();}}if (raf2 != null) {try {raf2.close();} catch (IOException e) {e.printStackTrace();}}}}/*使用RandomAccessFile实现文件内容的覆盖和追加*/@Testpublic void test2() {RandomAccessFile raf1 = null;try {// hello.txt内容为：abcdefghijklmnFile file = new File("hello.txt");raf1 = new RandomAccessFile(file, "rw");raf1.write("123".getBytes());// 从头开始覆盖：123defghijklmnraf1.seek(5);// 将指针调到角标为5的位置，角标从0开始raf1.write("456".getBytes());// 从角标为5处开始覆盖：123de456ijklmnraf1.seek(file.length());// 将指针调到文件末尾raf1.write("789".getBytes());// 在文件末尾追加：123de456ijklmn789} catch (IOException exception) {exception.printStackTrace();} finally {if (raf1 != null) {try {raf1.close();} catch (IOException exception) {exception.printStackTrace();}}}}/*使用RandomAccessFile实现数据的插入效果*/@Testpublic void test3() {RandomAccessFile raf1 = null;try {// hello.txt内容为：abcdefghijklmnFile file = new File("hello.txt");raf1 = new RandomAccessFile(file, "rw");// 将指针调到角标为3的位置，从此处开始读入文件的数据raf1.seek(3);// 方法一：保存指针3后面的所有数据到StringBuilder中/*StringBuilder builder = new StringBuilder((int) file.length());byte[] buffer = new byte[20];int len;while ((len = raf1.read(buffer)) != -1) {builder.append(new String(buffer, 0, len));}*/// 方法二：保存指针3后面的所有数据到ByteArrayOutputStream中ByteArrayOutputStream baos = new ByteArrayOutputStream();byte[] buffer = new byte[10];int len;while ((len = raf1.read(buffer)) != -1) {baos.write(buffer, 0, len);}// 经过上面的读操作后，指针位置移到了文件的末尾处// 调回指针，写入"123"，实际上是覆盖原文件内容raf1.seek(3);raf1.write("123".getBytes());// abc123ghijklmn// 经过上面的写入操作，指针位置已到了123后，紧接着：// 方法一：将StringBuilder中的数据写入到文件中，实际上是覆盖123后的内容// raf1.write(builder.toString().getBytes());// abc123defghijklmn// 方法二：将ByteArrayOutputStream中的数据写入到文件中raf1.write(baos.toString().getBytes());// abc123defghijklmn} catch (IOException exception) {exception.printStackTrace();} finally {if (raf1 != null) {try {raf1.close();} catch (IOException exception) {exception.printStackTrace();}}}}
}

I/O 流的关闭

一个流绑定了一个文件句柄（或网络端口），如果流不关闭，该文件（或端口）将始终处于被锁定（不能读取、写入、删除和重命名）状态，导致占用大量系统资源却没有释放，因此，必须要关闭流。

同时，在程序中打开的文件 I/O 资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以，需要显式关闭文件 I/O 资源。

try-catch-finally

语法格式：

try {// 声明并初始化资源ResourceType resource1 = createResource1();ResourceType resource2 = createResource2()} catch (ExceptionType1 e1) {// 处理异常类型 1} catch (ExceptionType2 e2) {// 处理异常类型 2} finally {// 在 finally 中关闭流if (resource1!= null) {try {resource1.close();} catch (IOException e) {// 处理关闭文件流时的异常}}if (resource2!= null) {try {resource2.close();} catch (IOException e) {// 处理关闭文件流时的异常}}
}

• 流一定要在 finally 语句中关闭，防止出现异常，导致无法关闭。
• 流关闭时，需要注意关闭的顺序，先声明的流后关闭。

try-catch-resources

try-catch-resources：是 Java 7 中引入的一种异常处理机制，用于自动关闭实现了java.lang.AutoCloseable接口（在 Java 7 中）或java.io.Closeable接口（在 Java 7 之前就存在，AutoCloseable 是 Closeable 的子接口）的资源。这些资源通常包括文件流（如 FileInputStream、FileOutputStream）、数据库连接（如 Connection）、网络连接等。

传统的资源管理在异常处理时可能会比较复杂，需要在 finally 块中手动关闭资源，以确保资源被正确释放，防止资源泄漏。而 try-catch-resources 简化了这个过程，它能够自动关闭资源，即使在 try 块中发生了异常。

语法格式：

 try (// 在这里声明并初始化需要自动关闭的资源，可以声明多个资源，以 ; 隔开ResourceType resource1 = createResource1();ResourceType resource2 = createResource2()) {// 使用资源进行操作，可能会抛出异常的代码块} catch (ExceptionType1 e1) {// 处理异常类型 1} catch (ExceptionType2 e2) {// 处理异常类型 2}

原文链接

https://github.com/ACatSmiling/zero-to-zero/blob/main/JavaLanguage/java-advanced.md