4.6 IO流 (InputOutput Stream)

文档摘要

Java IO流 (Input/Output Stream) 核心机制与实战指南 Java IO流是Java程序中处理数据输入与输出的核心机制。无论是读取本地文件、处理网络请求，还是进行内存数据交换，IO流都扮演着至关重要的角色。本文将全面解析Java IO流的分类（字节流与字符流）、核心类库的使用方法、性能优化技巧（如缓冲流），以及现代Java开发中推荐的资源管理模式，帮助开发者构建高效、健壮的IO操作代码。一、 Java IO流的核心概念与分类体系 Java IO流的设计基于流（Stream）的概念，数据就像水流一样从一个地方（数据源）流向另一个地方（数据目标）。Java提供了一组丰富的类和接口，使得开发者能够以统一的方式处理不同类型的数据源。 1.

Java IO流 (Input/Output Stream) 核心机制与实战指南

Java IO流是Java程序中处理数据输入与输出的核心机制。无论是读取本地文件、处理网络请求，还是进行内存数据交换，IO流都扮演着至关重要的角色。本文将全面解析Java IO流的分类（字节流与字符流）、核心类库的使用方法、性能优化技巧（如缓冲流），以及现代Java开发中推荐的 try-with-resources 资源管理模式，帮助开发者构建高效、健壮的IO操作代码。

一、 Java IO流的核心概念与分类体系

Java IO流的设计基于流（Stream） 的概念，数据就像水流一样从一个地方（数据源）流向另一个地方（数据目标）。Java提供了一组丰富的类和接口，使得开发者能够以统一的方式处理不同类型的数据源。

1.1 按数据单位分类：字节流与字符流

根据处理数据的基本单位，Java IO流主要分为两大核心阵营：

字节流 (Byte Stream)：以字节（8 bit）为单位处理数据。适用于处理二进制文件（如图片、音频、视频）或不需要字符编码转换的原始数据。
- 输入字节流 (InputStream)：用于从数据源读取字节数据。
- 输出字节流 (OutputStream)：用于向数据目标写入字节数据。
字符流 (Character Stream)：以字符（16 bit Unicode）为单位处理数据。专为处理文本文件设计，能够自动处理字符编码问题，避免乱码。
- 输入字符流 (Reader)：用于从数据源读取字符数据。
- 输出字符流 (Writer)：用于向数据目标写入字符数据。

1.2 按功能角色分类：节点流与处理流

根据流在数据传输过程中的角色和功能，可进一步划分为：

节点流 (Node Stream)：直接连接到物理数据源或数据目标的流。它们是数据传输的基础通道，例如 FileInputStream、FileOutputStream、FileReader、FileWriter。
处理流 (Process Stream)：也称为过滤流或包装流。它们不直接连接物理节点，而是“包装”在节点流或其他处理流之外，提供额外的增强功能（如缓冲、数据转换、对象序列化等），例如 BufferedInputStream、BufferedReader、PrintWriter。

下图展示了 Java IO 流的核心分类体系：

二、字节流 (Byte Stream) 详解与实战

2.1 输入字节流 InputStream

InputStream 是所有字节输入流的抽象基类，定义了读取字节数据的基本方法。常用的子类包括：

FileInputStream：从本地文件中读取字节数据。
ByteArrayInputStream：从内存中的字节数组读取数据。
BufferedInputStream：提供内部缓冲区，减少底层物理读取次数，显著提升读取效率。
ObjectInputStream：用于反序列化，读取Java对象。

实战演练：使用 FileInputStream 读取文件


import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamExample {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            // 替换为实际的文件路径
            fis = new FileInputStream("input.txt"); 
            int data;
            // read() 返回 0-255 的整数，到达文件末尾时返回 -1
            while ((data = fis.read()) != -1) {
                System.out.print((char) data); 
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) {
                    fis.close(); // 务必在 finally 块中关闭流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

注意：直接使用字节流读取包含多字节字符（如中文）的文本文件时，可能会因字符截断导致乱码。处理纯文本文件时，应优先选择字符流。

实战演练：使用 BufferedInputStream 提升读取性能


import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        try {
            // 将 FileInputStream 包装为 BufferedInputStream
            bis = new BufferedInputStream(new FileInputStream("input.txt")); 
            int data;
            while ((data = bis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bis != null) {
                    bis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedInputStream 内部维护了一个默认大小为 8KB 的缓冲区。它通过批量从底层文件系统读取数据到内存缓冲区，后续的 read() 操作直接从内存中获取，从而大幅减少了昂贵的磁盘 I/O 交互次数。

2.2 输出字节流 OutputStream

OutputStream 是所有字节输出流的抽象基类。常用的子类包括：

FileOutputStream：向本地文件写入字节数据。
ByteArrayOutputStream：将数据写入内存中的字节数组。
BufferedOutputStream：提供缓冲功能，提升写入效率。
ObjectOutputStream：用于序列化，将Java对象写入流中。

实战演练：使用 FileOutputStream 写入文件


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

public class FileOutputStreamExample {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            // 替换为实际的文件路径
            fos = new FileOutputStream("output.txt"); 
            String message = "Hello, World!";
            byte[] bytes = message.getBytes(); // 将字符串转换为平台默认编码的字节数组
            fos.write(bytes); 
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

实战演练：使用 BufferedOutputStream 提升写入性能


import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamExample {
    public static void main(String[] args) {
        BufferedOutputStream bos = null;
        try {
            bos = new BufferedOutputStream(new FileOutputStream("output.txt")); 
            String message = "Hello, Buffered World!";
            byte[] bytes = message.getBytes();
            bos.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bos != null) {
                    // 关闭 BufferedOutputStream 会自动触发 flush()，将缓冲区数据写入磁盘
                    bos.close(); 
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

三、字符流 (Character Stream) 详解与实战

3.1 输入字符流 Reader

Reader 是所有字符输入流的抽象基类，专门用于处理 Unicode 字符。常用的子类包括：

FileReader：从文件中读取字符数据（使用平台默认编码）。
CharArrayReader：从字符数组中读取数据。
BufferedReader：提供缓冲功能，并支持按行读取（readLine()）。
InputStreamReader：字节流到字符流的桥梁，支持指定字符编码。

实战演练：使用 BufferedReader 逐行高效读取


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("input.txt")); 
            String line;
            // readLine() 是 BufferedReader 特有的方法，极大简化了文本处理
            while ((line = br.readLine()) != null) {
                System.out.println(line); 
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

实战演练：使用 InputStreamReader 解决字符编码问题


import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class InputStreamReaderExample {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            // 使用 InputStreamReader 桥接字节流，并显式指定 UTF-8 编码
            br = new BufferedReader(
                new InputStreamReader(new FileInputStream("input.txt"), StandardCharsets.UTF_8)
            ); 
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

最佳实践：在实际开发中，强烈建议使用 InputStreamReader 包装 FileInputStream 并指定明确的字符集（如 StandardCharsets.UTF_8），而不是直接使用 FileReader，以避免跨平台运行时的默认编码不一致导致的乱码问题。

3.2 输出字符流 Writer

Writer 是所有字符输出流的抽象基类。常用的子类包括：

FileWriter：向文件中写入字符数据。
BufferedWriter：提供缓冲功能，提升写入效率。
OutputStreamWriter：字符流到字节流的桥梁，支持指定字符编码。
PrintWriter：提供便捷的格式化打印方法（如 println(), printf()）。

实战演练：使用 OutputStreamWriter 指定编码写入


import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;

public class OutputStreamWriterExample {
    public static void main(String[] args) {
        BufferedWriter bw = null;
        try {
            // 显式指定 UTF-8 编码，确保中文字符正确写入
            bw = new BufferedWriter(
                new OutputStreamWriter(new FileOutputStream("output.txt"), StandardCharsets.UTF_8)
            ); 
            String message = "你好，世界！"; 
            bw.write(message);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bw != null) {
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

实战演练：使用 PrintWriter 进行格式化输出


import java.io.PrintWriter;
import java.io.FileWriter;
import java.io.IOException;

public class PrintWriterExample {
    public static void main(String[] args) {
        PrintWriter pw = null;
        try {
            pw = new PrintWriter(new FileWriter("output.txt")); 
            pw.println("Hello, PrintWriter!");
            pw.printf("The answer is %d%n", 42); // 支持格式化字符串
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (pw != null) {
                pw.close(); // PrintWriter 的 close() 不会抛出 IOException
            }
        }
    }
}

四、 IO流的标准使用模式与资源管理

4.1 传统 IO 流操作模式

在早期的 Java 版本中，使用 IO 流必须遵循严格的“打开-操作-关闭”模式，且必须在 finally 块中确保资源被释放：

创建流对象：根据需求实例化节点流，并视情况包装处理流。
执行 IO 操作：调用 read() 或 write() 方法进行数据交互。
安全关闭流：在 finally 块中调用 close() 方法。关闭处理流时，会自动级联关闭其内部的节点流。

4.2 现代 Java 推荐：try-with-resources 语句

自 Java 7 起，引入了 try-with-resources 语法。只要资源类实现了 AutoCloseable 接口（Java 中的所有标准 IO 流均已实现），即可在 try 语句块结束时自动调用 close() 方法。这不仅消除了冗长的 finally 块，还避免了因异常覆盖导致的资源泄漏问题。

实战演练：使用 try-with-resources 简化代码


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        // 在 try 后的括号中声明并初始化资源
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) { 
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } 
        // 无需 finally 块，br 会在此处自动关闭
    }
}

五、总结与最佳实践

Java IO 流是构建企业级应用底层数据交互的基石。掌握其核心机制，能够显著提升代码的健壮性与执行效率。在实际开发中，建议遵循以下最佳实践：

明确流的选择：处理纯文本且关注字符编码时，优先使用字符流（配合 InputStreamReader/OutputStreamWriter 指定编码）；处理图片、音视频或序列化对象时，必须使用字节流。
善用缓冲流：在进行频繁的小数据量读写时，务必使用 BufferedInputStream、BufferedOutputStream、BufferedReader 或 BufferedWriter 进行包装，以空间换时间，大幅降低系统调用开销。
强制资源管理：全面拥抱 try-with-resources 语法，杜绝手动在 finally 中关闭流带来的代码冗余和潜在风险。
关注 NIO 扩展：对于高并发、大文件传输或需要非阻塞 IO 的场景，传统的 BIO（Blocking IO）流可能会成为性能瓶颈。此时应深入研究 Java NIO（New IO）体系，利用 Channel、Buffer 和 Selector 构建更高性能的网络与文件处理架构。

作者与出处

原作者：灏天文库

来源：灏天文库

原文： https://aiknowledge.cn/collection/133-java%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF%E4%B8%8E%E5%BC%80%E5%8F%91%E5%AE%9E%E6%88%98

整理：灏天文库整理

由灏天文库平台收录，内容或由平台用户上传，仅供学习交流