Java I/O — 输入输出全面笔记

I/O 的本质是数据在不同介质之间的流动。理解 I/O 的关键在于确定以内存为参照点：

• 输入（Input）：从外部往内存中读取数据
• 输出（Output）：从内存往外部写入数据

记忆口诀：外→内为输入，内→外为输出。永远站在内存的视角看问题。

当你把它作为参数传给 FileInputStream时，如果文件不存在就会创建出来。

File file = new File("test.txt");      // 只是内存中的一个路径对象，不是物理文件
FileInputStream fis = new FileInputStream(file);  // 此时如果文件不存在，则创建物理文件

FileInputStream和 FileOutputStream是 Java 中最基础的字节流，用于按字节读写文件。传路径或传File 对象都可以。

// 方式一：传路径字符串
InputStream inputStream = new FileInputStream("path/to/file.txt");
OutputStream outputStream = new FileOutputStream("path/to/file.txt");

// 方式二：传 File 对象
File file = new File("path/to/file.txt");
InputStream inputStream = new FileInputStream(file);
OutputStream outputStream = new FileOutputStream(file);

字节流体系的核心：InputStream 是抽象类，定义了 read()规范；具体实现类决定从哪里读（文件、字节数组、网络等）。

使用 try块来自动管理资源，无需手动调用 close()：

try (InputStream inputStream = new FileInputStream(file)) {
    // 使用 inputStream 读取数据
    int data = inputStream.read();
    // ...
} catch (IOException e) {
    e.printStackTrace();
}
// try 块结束时，inputStream.close() 会被自动调用

InputStream 只能读字节，Reader 才能读字符。在字节流之上再套一个 InputStreamReader来读取字符：

// 通用方式（推荐）：InputStreamReader 可以适配任何 InputStream
Reader reader = new InputStreamReader(inputStream);
// 不限于文件 — 网络流、内存流等任何 InputStream 都可以转成 Reader

当然也可以直接读文件：

// 便捷方式：直接从文件读取字符
Reader reader = new FileReader("path/to/file.txt");

这个设计相对更通用— 因为你并不是总是从文件里面读取数据，网络、内存、管道等各种来源都可以通过 InputStream→ InputStreamReader这条路径处理。

在 Reader之上再包一层 BufferedReader，实现整行读取：

BufferedReader bufferedReader = new BufferedReader(reader);
String line = bufferedReader.readLine();  // 整行整行地读

BufferedReader 的目的其实是一次性缓存更多字节，避免每次都从文件里面操作，减少磁盘 I/O 开销。

写的时候也可以用 Buffer：

BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
bufferedOutputStream.write(data);  // 并不会直接写入文件！
bufferedOutputStream.flush();      // 主动将缓冲区字节冲入文件

设计目的：主要是为了把多次的 I/O 操作合并成一次，减少磁盘操作次数，大幅提升性能。

// 原始流
InputStream in = ...;
// 套缓冲流（标准写法 — 有利无害）
BufferedInputStream bin = new BufferedInputStream(in);
// 再用 bin.read(buffer) 读
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = bin.read(buffer)) != -1) {
    // 处理读取到的数据
}

同理，OutputStream → BufferedOutputStream、Writer → BufferedWriter 也是一样的层次结构。

文件的"关闭"其实是内存的释放。

当你读写文件时，系统会腾出一块内存来存储文件的相关信息（文件描述符、缓冲区等），关闭文件 = 释放这块内存。

因为 InputStream和 OutputStream都实现了 Closeable接口，且 Reader也实现了 Closeable，BufferedReader又继承自 Reader，所以它们都可以通过 try 来自动管理资源。

// 所有实现了 Closeable 的都可以这样用
try (InputStream in = new FileInputStream("read.txt");
     OutputStream out = new FileOutputStream("write.txt");
     BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
     BufferedWriter writer = new BufferedWriter(new FileWriter("out.txt"))) {

    // 所有流都会在 try 块结束时自动关闭
    // 关闭顺序与声明顺序相反

} catch (IOException e) {
    e.printStackTrace();
}

Android 中复制文件的方法多种多样：

• FileUtils工具类提供现成的复制方法
• Kotlin 的 File自带扩展方法 copyTo()

Java 7+ 提供的 Files.copy()是最简单高效的文件复制方式：

// 最简单的复制方式
Path source = Paths.get("source.txt");
Path target = Paths.get("target.txt");
Files.copy(source, target);

// 覆盖已存在的目标文件
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);

// 保留文件属性（权限、时间戳等）
Files.copy(source, target, 
    StandardCopyOption.REPLACE_EXISTING,
    StandardCopyOption.COPY_ATTRIBUTES);

// 复制目录（不递归）
Files.copy(sourceDir, targetDir);

// 递归复制目录
Files.walk(sourceDir)
    .forEach(sourcePath -> {
        Path targetPath = targetDir.resolve(sourceDir.relativize(sourcePath));
        try {
            Files.copy(sourcePath, targetPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    });

纯 Java 就是一个字节一个字节地搬。其实那些复制文件的底层 API 也是一个一个字节照搬的，只是它们做了更多封装和优化。

// 纯 Java 文件复制 — 带缓冲的字节搬运
try (FileInputStream in = new FileInputStream("source.txt");
     FileOutputStream out = new FileOutputStream("target.txt")) {

    byte[] buffer = new byte[8192];  // 一次搬 8KB
    int bytesRead;
    while ((bytesRead = in.read(buffer)) != -1) {
        out.write(buffer, 0, bytesRead);  // 读到多少写多少
    }

} catch (IOException e) {
    e.printStackTrace();
}

Socket 的本质就是把网络连接也当成一个流来读写。和文件操作一样，你拿到的是 InputStream和 OutputStream。

try {
    Socket socket = new Socket("hencoder.com", 80);

    // 往网络输出（发送数据）
    OutputStream out = socket.getOutputStream();

    // 从网络读入（接收数据）
    InputStream in = socket.getInputStream();

} catch (IOException e) {
    e.printStackTrace();
}

其实套一层 Buffered 更好：

try {
    Socket socket = new Socket("hencoder.com", 80);

    // 用 BufferedWriter 按字符写入
    BufferedWriter writer = new BufferedWriter(
        new OutputStreamWriter(socket.getOutputStream())
    );

    // 用 BufferedReader 按字符读取
    BufferedReader reader = new BufferedReader(
        new InputStreamReader(socket.getInputStream())
    );

    // reader 和 writer 是根据【字符】来写入和读取的，而不是字节

} catch (IOException e) {
    e.printStackTrace();
}

// 发送 HTTP GET 请求报文
writer.write("GET / HTTP/1.1\n"
           + "Host: www.example.com\n"
           + "\n");  // 空行表示请求头结束

writer.flush();  // 一定要 flush！否则数据还在缓冲区

// 读取服务器响应
System.out.println(reader.readLine());

ServerSocket serverSocket = new ServerSocket(80);  // 监听 80 端口
Socket socket = serverSocket.accept();              // 阻塞等待客户端连接

// 别人连接你之后，你会得到一个 Socket 对象
// 然后可以调用这个 socket 对象来给对方发送消息

一样可以套一层 BufferedReader或 BufferedWriter：

BufferedReader reader = new BufferedReader(
    new InputStreamReader(socket.getInputStream())
);
BufferedWriter writer = new BufferedWriter(
    new OutputStreamWriter(socket.getOutputStream())
);

private static void io3() {
    try (
        ServerSocket serverSocket = new ServerSocket(8080);
        Socket socket = serverSocket.accept();
        BufferedReader bufferedReader = new BufferedReader(
            new InputStreamReader(socket.getInputStream())
        );
        BufferedWriter bufferedWriter = new BufferedWriter(
            new OutputStreamWriter(socket.getOutputStream())
        );
    ) {

        String html = """
            <!DOCTYPE html>
            <html>
            <head>
                <meta charset="UTF-8">
                <title>简单页面</title>
            </head>
            <body>
                <h1>Hello, World!</h1>
                <p>这是一个简单的HTML页面</p>
            </body>
            </html>
            """;

        bufferedWriter.write("HTTP/1.1 200 OK\r\n");
        bufferedWriter.write("Content-Type: text/html; charset=UTF-8\r\n");
        bufferedWriter.write("Content-Length: " + html.getBytes().length + "\r\n");
        bufferedWriter.write("\r\n");
        bufferedWriter.write(html);
        bufferedWriter.flush();

    } catch (IOException _) {}
}