IO流

Java I/O（输入/输出）是Java编程中用于处理输入和输出的核心API。它提供了丰富的类和方法来读取和写入数据，包括文件、网络流、内存流等。Java I/O主要分为两大类：字节流和字符流。下面我们将详细讲解Java I/O的主要知识点和使用方法。

1. 字节流（Byte Streams）

字节流用于处理二进制数据，如图片、音频、视频等。字节流的核心类是 InputStream 和 OutputStream。

1.1 InputStream

InputStream 是所有字节输入流的基类。常见的子类有：

• FileInputStream：用于从文件中读取字节数据。
• ByteArrayInputStream：从字节数组中读取数据。
• BufferedInputStream：提供缓冲功能，提高读取效率。

示例：使用 FileInputStream 读取文件

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

public class FileInputStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("example.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.2 OutputStream

OutputStream 是所有字节输出流的基类。常见的子类有：

• FileOutputStream：用于向文件中写入字节数据。
• ByteArrayOutputStream：将数据写入字节数组。
• BufferedOutputStream：提供缓冲功能，提高写入效率。

示例：使用 FileOutputStream 写入文件

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

public class FileOutputStreamExample {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            String text = "Hello, World!";
            fos.write(text.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 字符流（Character Streams）

字符流用于处理文本数据，如字符串、文本文件等。字符流的核心类是 Reader 和 Writer。

2.1 Reader

Reader 是所有字符输入流的基类。常见的子类有：

• FileReader：用于从文件中读取字符数据。
• BufferedReader：提供缓冲功能，提高读取效率。

示例：使用 BufferedReader 读取文件

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

public class BufferedReaderExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.2 Writer

Writer 是所有字符输出流的基类。常见的子类有：

• FileWriter：用于向文件中写入字符数据。
• BufferedWriter：提供缓冲功能，提高写入效率。

示例：使用 BufferedWriter 写入文件

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

public class BufferedWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            bw.write("Hello, World!");
            bw.newLine();
            bw.write("This is a new line.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. 缓冲流（Buffered Streams）

缓冲流通过在内存中创建缓冲区来提高I/O操作的效率。缓冲流可以包装其他流，如 BufferedInputStream、BufferedOutputStream、BufferedReader 和 BufferedWriter。

示例：使用 BufferedInputStream 和 BufferedOutputStream 复制文件

import java.io.*;

public class BufferedStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. 对象序列化（Object Serialization）

Java 提供了对象序列化机制，可以将对象转换为字节流，以便存储或传输。实现 Serializable 接口的类可以被序列化。

示例：对象序列化和反序列化

import java.io.*;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private 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();
        }
    }
}

5. NIO（New I/O）

Java NIO 提供了非阻塞I/O操作，适用于高并发场景。NIO 的核心组件包括 Channel、Buffer 和 Selector。

示例：使用 FileChannel 复制文件

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class NIOExample {
    public static void main(String[] args) {
        try (FileChannel sourceChannel = FileChannel.open(Paths.get("input.txt"), StandardOpenOption.READ);
             FileChannel destChannel = FileChannel.open(Paths.get("output.txt"), StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while (sourceChannel.read(buffer) != -1) {
                buffer.flip();
                destChannel.write(buffer);
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6. 总结

Java I/O 提供了丰富的API来处理各种输入输出操作。字节流适用于处理二进制数据，字符流适用于处理文本数据。缓冲流可以提高I/O操作的效率，对象序列化机制可以方便地存储和传输对象。NIO 提供了非阻塞I/O操作，适用于高并发场景。

在实际开发中，应根据具体需求选择合适的I/O类和方式，并注意资源的释放（如使用 try-with-resources 语句）以避免资源泄漏。