5bei.cn大模型教程网目录
1. 字节流（InputStream/OutputStream）与字符流（Reader/Writer）的区别
2. 缓冲流（BufferedInputStream）的加速原理
1. 为什么流必须关闭？try-with-resources 语法如何自动释放资源？
2. 复制大文件时用 ByteArrayOutputStream 为何会内存溢出？
1. 对比传统 IO（阻塞式）与 NIO（非阻塞、基于通道和缓冲区）的优势
2. 用 ByteBuffer 和 FileChannel 实现高效文件读写
在 Java 编程中，输入输出（I/O）操作是与外部世界交互的重要桥梁，无论是读取文件、网络通信还是处理用户输入，都离不开 I/O 流的身影。从最初的字节流、字符流，到后来的 NIO（New I/O），Java 的 I/O 体系不断进化，为开发者提供了更高效、更灵活的操作方式。本文将带你深入了解 Java I/O 流的世界，从基础的流体系划分，到常见的操作陷阱，再到 NIO 的入门知识，全方位掌握 I/O 流的进化与应用。
一、流的体系划分：字节与字符的分野，缓冲的加速奥秘
Java 的 I/O 流体系庞大而有序，根据处理数据的单位和功能特点，可以划分为不同的类别，其中最基础的便是字节流和字符流，而缓冲流则是在它们基础上提升性能的重要存在。
1. 字节流（InputStream/OutputStream）与字符流（Reader/Writer）的区别
字节流以字节为单位处理数据，主要用于处理二进制文件，如图片、音频、视频等，其核心类是InputStream和OutputStream。InputStream是所有字节输入流的父类，提供了读取字节的基本方法；OutputStream是所有字节输出流的父类，提供了写入字节的基本方法。
例如，使用FileInputStream读取一个图片文件：
try (InputStream in = new FileInputStream("image.jpg")) {
byte[] buffer = new byte[1024];
int len;
while ((len = in.read(buffer)) != -1) {
// 处理读取到的字节数据
}
} catch (IOException e) {
e.printStackTrace();
}字符流则以字符为单位处理数据，主要用于处理文本文件，如.txt、.java 等，其核心类是Reader和Writer。字符流会涉及到字符编码的转换，它能将字节按照指定的编码格式转换为字符，避免了直接操作字节可能出现的乱码问题。
比如，使用FileReader读取一个文本文件：
try (Reader reader = new FileReader("text.txt")) {
char[] buffer = new char[1024];
int len;
while ((len = reader.read(buffer)) != -1) {
String content = new String(buffer, 0, len);
// 处理读取到的字符数据
}
} catch (IOException e) {
e.printStackTrace();
}两者的主要区别在于处理的数据单位不同，字节流适用于所有类型的文件，而字符流更适合处理文本文件，且能更好地处理字符编码问题。
2. 缓冲流（BufferedInputStream）的加速原理
缓冲流（如BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter）是为了提高 I/O 操作的效率而设计的。它们的核心原理是在内存中设置一个缓冲区，当进行读写操作时，先将数据读取到缓冲区或从缓冲区写入，而不是每次都直接与磁盘或网络等外部设备交互。
我们知道，与外部设备的交互速度相对较慢，而内存中的操作速度则快得多。缓冲流通过减少与外部设备的交互次数来提升性能。例如，BufferedInputStream会一次性从输入流中读取一定量的数据到缓冲区，当程序需要读取数据时，先从缓冲区中获取，如果缓冲区中的数据用完了，再从输入流中读取新的数据到缓冲区。
举个例子，不使用缓冲流读取文件时，每一次read操作都可能触发一次磁盘访问；而使用BufferedInputStream后，会先将一批数据读入缓冲区，后续的read操作大多只需从缓冲区获取，大大减少了磁盘访问次数，从而提高了读取速度。
二、常见操作陷阱：资源释放与大文件处理的那些坑
在使用 I/O 流的过程中，有一些常见的操作陷阱需要格外注意，稍不留意就可能导致资源泄露、程序异常等问题。
1. 为什么流必须关闭？try-with-resources 语法如何自动释放资源？
流操作涉及到与外部资源（如文件句柄、网络连接等）的交互，这些资源在操作系统中是有限的。如果使用完流之后不关闭，就会导致这些资源被一直占用，无法被其他程序使用，久而久之可能会造成资源耗尽，使程序无法正常运行，这就是所谓的资源泄露。
在 Java 7 之前，我们需要手动在finally块中关闭流，确保无论操作是否出现异常，流都能被关闭：
InputStream in = null;
try {
in = new FileInputStream("file.txt");
// 读取操作
} catch (IOException e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}这种方式代码繁琐，容易出错。Java 7 引入的 try-with-resources 语法很好地解决了这个问题。它允许在try关键字后面的括号中声明一个或多个资源，这些资源必须实现AutoCloseable接口。当try块执行完毕后，无论是否出现异常，这些资源都会被自动关闭。
使用 try-with-resources 语法关闭流的示例：
try (InputStream in = new FileInputStream("file.txt")) {
// 读取操作
} catch (IOException e) {
e.printStackTrace();
}这样的代码更加简洁，且能确保资源被正确释放，有效避免了资源泄露问题。
2. 复制大文件时用 ByteArrayOutputStream 为何会内存溢出？
ByteArrayOutputStream是一个将数据写入字节数组的输出流，它会在内存中创建一个字节数组来存储数据。当复制大文件时，如果使用ByteArrayOutputStream，会将整个文件的内容都存储到内存中的字节数组里。
大文件的体积可能非常大，甚至超过了 JVM 的内存限制。此时，ByteArrayOutputStream会不断地扩容内部的字节数组，当所需的内存超过 JVM 所能提供的最大内存时，就会抛出OutOfMemoryError，导致内存溢出。
因此，在复制大文件时，不建议使用ByteArrayOutputStream，而应该使用基于磁盘的输出流，如FileOutputStream，并采用边读边写的方式，即读取一部分数据，就立即写入到目标文件中，避免将整个文件内容加载到内存中。
例如，使用字节流复制大文件的正确方式：
try (InputStream in = new FileInputStream("largeFile.iso");
OutputStream out = new FileOutputStream("copy.iso")) {
byte[] buffer = new byte[8192];
int len;
while ((len = in.read(buffer)) != -1) {
out.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}三、NIO 入门：非阻塞的高效 I/O 新体验
传统的 IO 是阻塞式的，在进行读写操作时，线程会一直等待，直到操作完成，这在高并发场景下会导致性能瓶颈。NIO 的出现改变了这一局面，它提供了非阻塞的 I/O 操作方式，基于通道（Channel）和缓冲区（Buffer），大大提高了 I/O 操作的效率。
1. 对比传统 IO（阻塞式）与 NIO（非阻塞、基于通道和缓冲区）的优势
传统 IO 的阻塞特性意味着当一个线程执行read或write操作时，如果数据没有准备好或无法立即写入，线程就会被挂起，处于阻塞状态，无法进行其他工作。这在处理大量并发连接时，会需要创建大量的线程，而线程的创建和切换成本很高，会严重影响系统性能。
NIO 则采用非阻塞模式，线程在进行 I/O 操作时，如果数据没有准备好，不会被阻塞，而是可以去处理其他任务，当数据准备好后，再回来处理。这种方式减少了线程的阻塞时间，提高了线程的利用率。
此外，NIO 基于通道和缓冲区进行操作。通道是双向的，可以同时进行读写操作，而传统 IO 的流是单向的。缓冲区是一块连续的内存区域，数据的读写都必须通过缓冲区进行，这种方式使得数据操作更加高效。
2. 用 ByteBuffer 和 FileChannel 实现高效文件读写
在 NIO 中，ByteBuffer是最常用的缓冲区，FileChannel则是用于文件操作的通道。使用它们可以实现高效的文件读写。
下面是一个使用ByteBuffer和FileChannel读取文件的示例：
try (FileChannel channel = new FileInputStream("file.txt").getChannel()) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead;
while ((bytesRead = channel.read(buffer)) != -1) {
buffer.flip(); // 切换为读模式
byte[] bytes = new byte[bytesRead];
buffer.get(bytes);
String content = new String(bytes);
// 处理读取到的内容
buffer.clear(); // 清空缓冲区，准备下次读取
}
} catch (IOException e) {
e.printStackTrace();
}写入文件的示例：
try (FileChannel channel = new FileOutputStream("output.txt").getChannel()) {
String content = "Hello, NIO!";
ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());
channel.write(buffer);
} catch (IOException e) {
e.printStackTrace();
}在上述代码中，ByteBuffer的allocate方法用于分配指定大小的缓冲区，flip方法将缓冲区从写模式切换为读模式，clear方法清空缓冲区以便下次使用。FileChannel的read方法将数据从通道读入缓冲区，write方法将缓冲区中的数据写入通道。
通过这种方式，数据的读写通过缓冲区进行，减少了与磁盘的直接交互次数，再结合 NIO 的非阻塞特性，能够实现高效的文件操作。
结语
Java I/O 流的发展见证了 Java 语言在处理输入输出操作上的不断优化。从最初的字节流、字符流，到缓冲流的性能提升，再到 NIO 带来的非阻塞、高效操作，每一次进化都为开发者提供了更好的工具。
在实际开发中，我们需要根据具体的场景选择合适的 I/O 方式：处理二进制文件用字节流，处理文本文件用字符流，追求性能时使用缓冲流，面对高并发、大文件处理等场景则可以考虑 NIO。同时，要注意避免常见的操作陷阱，如及时关闭资源、合理处理大文件等。
掌握 Java I/O 流的知识，不仅能让我们更好地完成日常的开发任务，还能深入理解 Java 底层的资源管理机制，为写出高效、健壮的程序打下坚实的基础。
文章来源于互联网:Java I/O 流：从字节流到 NIO 的进化与应用
刚刚，Scopus数据库再次迎来更新！这也是本年第七次更新。 与上次更新相比，本次Scopus来源出版物列表(Scopus Sources)共有47758本期刊被收录。其中： ● 5本期刊不再被数据库收录(Discontinued Titles) ● 新增34…
