当前位置：首页 > news >正文

Java IO 流：从入门到实践

news 来源：原创 2025/5/25 10:29:02

引言

什么是 IO 流？

IO 流的分类

1. 按数据流向

2. 按数据类型

3. 按功能

常用 IO 流类

IO 流的使用

1. 字节流示例：文件复制

2. 字符流示例：文件读写

3. 缓冲流示例：高效文件读写

4. 对象序列化示例

IO 流的最佳实践

总结

引言

在 Java 编程中，IO 流（Input/Output Stream）是处理输入输出操作的核心工具。无论是读写文件、网络通信，还是处理用户输入，IO 流都扮演着重要角色。本文将详细介绍 Java IO 流的基本概念、分类以及常见用法，并通过代码示例帮助你快速掌握 IO 流的使用。

什么是 IO 流？

IO 流是 Java 中用于处理输入输出操作的抽象概念。它可以将数据从一个地方传输到另一个地方，例如从文件读取数据或将数据写入网络。IO 流的核心思想是流式处理，即数据像水流一样从一个地方流向另一个地方。

IO 流的分类

Java 中的 IO 流可以分为以下几类：

1. 按数据流向

输入流（Input Stream）：用于从外部读取数据（如文件、网络）。
输出流（Output Stream）：用于向外部写入数据。

2. 按数据类型

字节流（Byte Stream）：以字节为单位读写数据，适用于所有类型的数据。
- 输入流：InputStream
- 输出流：OutputStream
字符流（Character Stream）：以字符为单位读写数据，适用于文本数据。
- 输入流：Reader
- 输出流：Writer

3. 按功能

节点流（Node Stream）：直接操作数据源（如文件、网络）。
处理流（Processing Stream）：对节点流进行封装，提供额外的功能（如缓冲、数据转换）。

常用 IO 流类

以下是 Java 中常用的 IO 流类：

分类	字节流	字符流
输入流	`InputStream`	`Reader`
输出流	`OutputStream`	`Writer`
文件操作	`FileInputStream`	`FileReader`
	`FileOutputStream`	`FileWriter`
缓冲流	`BufferedInputStream`	`BufferedReader`
	`BufferedOutputStream`	`BufferedWriter`
数据转换	`DataInputStream`	`InputStreamReader`
	`DataOutputStream`	`OutputStreamWriter`
对象序列化	`ObjectInputStream`	-
	`ObjectOutputStream`	-

IO 流的使用

1. 字节流示例：文件复制

以下代码使用字节流实现文件的复制：

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

public class ByteStreamExample {
    public static void main(String[] args) {
        String sourceFile = "source.txt";
        String targetFile = "target.txt";

        try (FileInputStream fis = new FileInputStream(sourceFile);
             FileOutputStream fos = new FileOutputStream(targetFile)) {

            byte[] buffer = new byte[1024];
            int bytesRead;

            // 读取源文件并写入目标文件
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }

            System.out.println("文件复制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 字符流示例：文件读写

以下代码使用字符流实现文件的读写：

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharacterStreamExample {
    public static void main(String[] args) {
        String sourceFile = "source.txt";
        String targetFile = "target.txt";

        try (FileReader fr = new FileReader(sourceFile);
             FileWriter fw = new FileWriter(targetFile)) {

            int character;

            // 读取源文件并写入目标文件
            while ((character = fr.read()) != -1) {
                fw.write(character);
            }

            System.out.println("文件读写完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. 缓冲流示例：高效文件读写

以下代码使用缓冲流提高文件读写的效率：

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

public class BufferedStreamExample {
    public static void main(String[] args) {
        String sourceFile = "source.txt";
        String targetFile = "target.txt";

        try (BufferedReader br = new BufferedReader(new FileReader(sourceFile));
             BufferedWriter bw = new BufferedWriter(new FileWriter(targetFile))) {

            String line;

            // 逐行读取源文件并写入目标文件
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine(); // 写入换行符
            }

            System.out.println("文件读写完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. 对象序列化示例

以下代码演示如何使用对象流实现对象的序列化和反序列化：

import java.io.*;

class Student implements Serializable {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + "}";
    }
}

public class ObjectStreamExample {
    public static void main(String[] args) {
        String file = "student.dat";

        // 序列化对象
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file))) {
            Student student = new Student("Alice", 20);
            oos.writeObject(student);
            System.out.println("对象序列化完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化对象
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
            Student student = (Student) ois.readObject();
            System.out.println("反序列化对象: " + student);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}