Java IO流案例

本文目录导读：

1. 文件基础读写操作
2. 字符流读写文件
3. 缓冲流提高性能
4. 对象序列化与反序列化
5. 递归遍历目录
6. 合并多个文件
7. 控制台输入输出
8. 文件属性操作
9. 运行示例

我将为您展示几个Java IO流的经典案例，涵盖文件读写、缓冲流、对象序列化等常用场景。

文件基础读写操作

import java.io.*;
public class FileBasicIO {
    public static void main(String[] args) {
        // 案例1: 使用FileInputStream和FileOutputStream复制文件
        String sourcePath = "source.txt";
        String destPath = "dest.txt";
        try (FileInputStream fis = new FileInputStream(sourcePath);
             FileOutputStream fos = new FileOutputStream(destPath)) {
            int data;
            byte[] buffer = new byte[1024];
            while ((data = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, data);
            }
            System.out.println("文件复制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流读写文件

import java.io.*;
public class CharStreamExample {
    public static void main(String[] args) {
        // 使用FileReader和FileWriter进行字符流操作
        try (FileReader reader = new FileReader("input.txt");
             FileWriter writer = new FileWriter("output.txt")) {
            char[] buffer = new char[1024];
            int length;
            while ((length = reader.read(buffer)) != -1) {
                writer.write(buffer, 0, length);
            }
            System.out.println("字符流写入完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 读取文本文件内容
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲流提高性能

import java.io.*;
public class BufferedStreamExample {
    public static void main(String[] args) {
        // 使用BufferedInputStream和BufferedOutputStream提高读写效率
        try (BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("large_file.zip"));
             BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("large_file_copy.zip"))) {
            byte[] buffer = new byte[8192]; // 8KB缓冲区
            int bytesRead;
            long startTime = System.currentTimeMillis();
            while ((bytesRead = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, bytesRead);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("大文件复制完成，耗时：" + (endTime - startTime) + "ms");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象序列化与反序列化

import java.io.*;
// 定义可序列化的对象
class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private transient String password; // transient字段不会被序列化
    public Person(String name, int age, String password) {
        this.name = name;
        this.age = age;
        this.password = password;
    }
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", password='" + password + "'}";
    }
}
public class ObjectSerializationExample {
    public static void main(String[] args) {
        // 序列化对象到文件
        Person person = new Person("张三", 25, "secret123");
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("person.dat"))) {
            oos.writeObject(person);
            System.out.println("对象序列化成功: " + person);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 从文件反序列化对象
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("person.dat"))) {
            Person deserializedPerson = (Person) ois.readObject();
            System.out.println("对象反序列化成功: " + deserializedPerson);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

递归遍历目录

import java.io.File;
public class DirectoryTraversal {
    public static void main(String[] args) {
        File directory = new File("C:/Users/Example/Desktop");
        if (directory.exists() && directory.isDirectory()) {
            listFilesRecursively(directory, 0);
        }
    }
    public static void listFilesRecursively(File dir, int level) {
        File[] files = dir.listFiles();
        if (files == null) return;
        StringBuilder indent = new StringBuilder();
        for (int i = 0; i < level; i++) {
            indent.append("  ");
        }
        for (File file : files) {
            if (file.isDirectory()) {
                System.out.println(indent + "📁 " + file.getName());
                listFilesRecursively(file, level + 1);
            } else {
                System.out.println(indent + "📄 " + file.getName() + 
                    " (" + file.length() + " bytes)");
            }
        }
    }
}

合并多个文件

import java.io.*;
import java.util.Arrays;
import java.util.List;
public class FileMergeExample {
    public static void main(String[] args) {
        List<String> sourceFiles = Arrays.asList("part1.txt", "part2.txt", "part3.txt");
        String outputFile = "merged.txt";
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile))) {
            for (String sourceFile : sourceFiles) {
                try (BufferedReader reader = new BufferedReader(new FileReader(sourceFile))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        writer.write(line);
                        writer.newLine();
                    }
                    System.out.println("已合并文件: " + sourceFile);
                } catch (IOException e) {
                    System.err.println("读取文件失败: " + sourceFile);
                }
            }
            System.out.println("所有文件合并完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

控制台输入输出

import java.io.*;
public class ConsoleIOExample {
    public static void main(String[] args) {
        // 使用BufferedReader读取控制台输入
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(System.in))) {
            System.out.print("请输入姓名: ");
            String name = reader.readLine();
            System.out.print("请输入年龄: ");
            int age = Integer.parseInt(reader.readLine());
            System.out.println("您输入的信息: 姓名=" + name + ", 年龄=" + age);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 使用Console类（在支持控制台的环境中使用）
        Console console = System.console();
        if (console != null) {
            String username = console.readLine("用户名: ");
            char[] password = console.readPassword("密码: ");
            console.printf("登录成功！欢迎 %s%n", username);
        }
    }
}

文件属性操作

import java.io.File;
import java.io.IOException;
import java.nio.file.*;
public class FileAdvancedOperations {
    public static void main(String[] args) {
        // 使用NIO.2 API（Java 7+）
        Path source = Paths.get("source.txt");
        Path target = Paths.get("copy.txt");
        try {
            // 文件复制
            Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件复制完成");
            // 文件移动
            Path dest = Paths.get("moved.txt");
            Files.move(target, dest, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件移动完成");
            // 读取文件属性
            BasicFileAttributes attrs = Files.readAttributes(dest, BasicFileAttributes.class);
            System.out.println("创建时间: " + attrs.creationTime());
            System.out.println("最后修改时间: " + attrs.lastModifiedTime());
            System.out.println("文件大小: " + attrs.size() + " bytes");
            // 删除文件
            Files.delete(dest);
            System.out.println("文件删除完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行示例

public class IOExamples {
    public static void main(String[] args) {
        System.out.println("=== Java IO 流案例 ===");
        System.out.println("1. 基础文件操作");
        System.out.println("2. 字符流操作");
        System.out.println("3. 缓冲流操作");
        System.out.println("4. 对象序列化");
        System.out.println("5. 目录遍历");
        System.out.println("6. 文件合并");
        System.out.println("7. 控制台输入输出");
        System.out.println("8. 文件属性操作");
    }
}

这些案例覆盖了Java IO流的主要使用场景：

1. 字节流：处理二进制数据
2. 字符流：处理文本数据
3. 缓冲流：提高I/O性能
4. 对象流：对象序列化与反序列化
5. 文件操作：文件创建、读写、复制、删除等
6. 目录操作：遍历、创建目录等
7. 控制台I/O：键盘输入、屏幕输出

在实际开发中,根据需求选择合适的流类型至关重要，建议优先使用缓冲流来提高性能，使用try-with-resources自动管理资源。