Java 输入/输出（I/O）操作（10/30）

news2024/11/25 15:55:13

Java 输入/输出（I/O）操作

1. Java I/O 类体系结构

2. 文件读写操作

2.1 使用 FileInputStream 和 FileOutputStream 进行字节流读写

2.2 使用 FileReader 和 FileWriter 进行字符流读写

3. 缓冲流的使用

3.1 使用 BufferedReader 和 BufferedWriter

4. 使用 Scanner 和 PrintWriter 进行文件操作

5. 序列化与反序列化

5.1 使用 ObjectOutputStream 和 ObjectInputStream

总结与后续

Java 输入/输出（I/O）操作

在软件开发中，输入/输出（I/O） 操作是非常常见的需求，它涉及到数据的读写与传输。Java 提供了强大的 I/O 类库，使得开发者可以方便地对文件、控制台、网络流等进行读写操作。本模块将介绍 Java 中的 I/O 类体系、文件读写、缓冲流和字符流的使用，帮助你掌握如何处理数据的输入和输出。

1. Java I/O 类体系结构

Java 的 I/O 类库主要包含在 java.io 和 java.nio 包中，提供了一系列用于操作字节流和字符流的类。

字节流：用于处理二进制数据，类名以 InputStream 或 OutputStream 结尾。
字符流：用于处理文本数据，类名以 Reader 或 Writer 结尾。

类名	描述
`InputStream`	字节输入流的抽象类
`OutputStream`	字节输出流的抽象类
`FileInputStream`	从文件中读取字节的输入流
`FileOutputStream`	向文件中写入字节的输出流
`Reader`	字符输入流的抽象类
`Writer`	字符输出流的抽象类
`FileReader`	从文件中读取字符的输入流
`FileWriter`	向文件中写入字符的输出流
`BufferedReader`	带缓冲的字符输入流
`BufferedWriter`	带缓冲的字符输出流

2. 文件读写操作

文件读写是 Java I/O 操作中最常见的应用场景之一。我们可以使用 FileInputStream 和 FileOutputStream 处理字节流，或者使用 FileReader 和 FileWriter 处理字符流。

2.1 使用 `FileInputStream` 和 `FileOutputStream` 进行字节流读写

示例：

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

public class ByteStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们使用 FileInputStream 从 input.txt 中读取字节，并将它们通过 FileOutputStream 写入到 output.txt 中。

2.2 使用 `FileReader` 和 `FileWriter` 进行字符流读写

示例：

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

public class CharStreamExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("input.txt");
             FileWriter fw = new FileWriter("output.txt")) {
            int data;
            while ((data = fr.read()) != -1) {
                fw.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们使用 FileReader 和 FileWriter 来读取和写入字符文件。这种方法适用于处理文本数据。

3. 缓冲流的使用

缓冲流（Buffered Stream）可以提高 I/O 操作的效率。缓冲流通过减少与底层系统的交互次数，显著提升了读写速度。

3.1 使用 `BufferedReader` 和 `BufferedWriter`

示例：

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) {
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们使用 BufferedReader 逐行读取文件内容，并使用 BufferedWriter 将内容写入到另一个文件中。readLine() 方法每次读取一整行，newLine() 方法用于写入系统的行分隔符。

4. 使用 `Scanner` 和 `PrintWriter` 进行文件操作

Scanner 类可以方便地从文件中读取数据，而 PrintWriter 类则用于将数据格式化输出到文件中。

示例：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;

public class ScannerPrintWriterExample {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(new File("input.txt"));
             PrintWriter writer = new PrintWriter("output.txt")) {
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                writer.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们使用 Scanner 逐行读取文件内容，并使用 PrintWriter 将内容写入到另一个文件中。Scanner 和 PrintWriter 提供了方便的方法来处理文本数据的输入和输出。

5. 序列化与反序列化

序列化 是将对象的状态转换为字节流的过程，以便将其保存到文件或通过网络传输。反序列化 是从字节流中恢复对象的过程。

5.1 使用 `ObjectOutputStream` 和 `ObjectInputStream`

示例：

import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.io.IOException;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int age;

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

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

public class SerializationExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);

        // 序列化对象
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化对象
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person deserializedPerson = (Person) ois.readObject();
            System.out.println("反序列化后的对象: " + deserializedPerson);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，Person 类实现了 Serializable 接口，以使对象可以被序列化。我们使用 ObjectOutputStream 将对象保存到文件中，并使用 ObjectInputStream 从文件中读取对象。