Java IO

Java IO（Input/Output）提供了丰富的类用于处理输入输出操作，包括文件读写、网络通信等。

IO 流分类

按数据流向分类

• 输入流（InputStream/Reader）：从外部读取数据到程序
• 输出流（OutputStream/Writer）：从程序写入数据到外部

按数据类型分类

• 字节流（Byte Stream）：以字节为单位处理数据
  • InputStream / OutputStream
• 字符流（Character Stream）：以字符为单位处理数据
  • Reader / Writer

文件操作

字节流操作文件

import java.io.*;

// 写入文件
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
    String data = "Hello, Java IO!";
    fos.write(data.getBytes());
}

// 读取文件
try (FileInputStream fis = new FileInputStream("output.txt")) {
    byte[] buffer = new byte[1024];
    int length;
    while ((length = fis.read(buffer)) != -1) {
        System.out.println(new String(buffer, 0, length));
    }
}

字符流操作文件

import java.io.*;

// 写入文件
try (FileWriter writer = new FileWriter("output.txt")) {
    writer.write("Hello, Java IO!");
}

// 读取文件
try (FileReader reader = new FileReader("output.txt")) {
    char[] buffer = new char[1024];
    int length;
    while ((length = reader.read(buffer)) != -1) {
        System.out.println(new String(buffer, 0, length));
    }
}

缓冲流

使用缓冲流可以提高 IO 性能：

import java.io.*;

// 缓冲字节流
try (BufferedInputStream bis = new BufferedInputStream(
        new FileInputStream("input.txt"));
     BufferedOutputStream bos = new BufferedOutputStream(
        new FileOutputStream("output.txt"))) {
    
    byte[] buffer = new byte[1024];
    int length;
    while ((length = bis.read(buffer)) != -1) {
        bos.write(buffer, 0, length);
    }
}

// 缓冲字符流
try (BufferedReader reader = new BufferedReader(
        new FileReader("input.txt"));
     BufferedWriter writer = new BufferedWriter(
        new FileWriter("output.txt"))) {
    
    String line;
    while ((line = reader.readLine()) != null) {
        writer.write(line);
        writer.newLine();
    }
}

NIO（New IO）

Java NIO 提供了非阻塞 IO 操作，性能更高。

Channel 和 Buffer

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

// 读取文件
try (FileChannel channel = FileChannel.open(
        Paths.get("input.txt"), StandardOpenOption.READ)) {
    
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    while (channel.read(buffer) != -1) {
        buffer.flip(); // 切换为读模式
        while (buffer.hasRemaining()) {
            System.out.print((char) buffer.get());
        }
        buffer.clear(); // 清空缓冲区
    }
}

对象序列化

Java 支持对象的序列化和反序列化：

import java.io.*;

// 序列化对象
class Person implements Serializable {
    private String name;
    private int age;
    
    // getter/setter...
}

// 写入对象
try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("person.ser"))) {
    Person person = new Person("张三", 25);
    oos.writeObject(person);
}

// 读取对象
try (ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("person.ser"))) {
    Person person = (Person) ois.readObject();
    System.out.println(person.getName());
}

文件操作工具类

Files 类（Java 7+）

import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

// 读取文件
String content = new String(Files.readAllBytes(Paths.get("input.txt")));

// 写入文件
Files.write(Paths.get("output.txt"), 
    "Hello".getBytes(), 
    StandardOpenOption.CREATE);

// 复制文件
Files.copy(Paths.get("source.txt"), Paths.get("dest.txt"));

总结

Java IO 提供了多种方式处理输入输出操作。选择合适的 IO 方式可以提高程序性能。对于大量数据操作，建议使用缓冲流或 NIO；对于简单操作，可以使用 Files 工具类。