Java文件流案例如何操作文件

本文目录导读：

1. 基本文件读写操作
2. 对象序列化
3. 随机访问文件
4. 文件属性操作
5. 目录遍历与文件过滤
6. 实用工具类
7. 使用示例
8. 注意事项

我来详细介绍Java文件流的操作方法,包含多个实际案例。

基本文件读写操作

字节流复制文件

import java.io.*;
public class FileStreamDemo {
    // 使用字节流复制文件
    public static void copyFileByByte(String sourcePath, String destPath) {
        try (FileInputStream fis = new FileInputStream(sourcePath);
             FileOutputStream fos = new FileOutputStream(destPath)) {
            byte[] buffer = new byte[1024]; // 1KB缓冲区
            int length;
            while ((length = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, length);
            }
            System.out.println("文件复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        copyFileByByte("input.txt", "output.txt");
    }
}

字符流读写文件

public class CharStreamDemo {
    // 使用字符流读取文件
    public static void readFile(String filePath) {
        try (FileReader reader = new FileReader(filePath)) {
            int character;
            StringBuilder content = new StringBuilder();
            while ((character = reader.read()) != -1) {
                content.append((char) character);
            }
            System.out.println("文件内容：\n" + content.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 使用BufferedReader高效读取
    public static void readFileEfficiently(String filePath) {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 使用BufferedWriter写入文件
    public static void writeFile(String filePath, String content) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            writer.write(content);
            writer.newLine();
            writer.write("这是第二行内容");
            System.out.println("文件写入成功！");
        } 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 ObjectStreamDemo {
    // 序列化对象到文件
    public static void serializeObject(String filePath) {
        Person person = new Person("张三", 25, "123456");
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath))) {
            oos.writeObject(person);
            System.out.println("对象序列化成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 从文件反序列化对象
    public static void deserializeObject(String filePath) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath))) {
            Person person = (Person) ois.readObject();
            System.out.println("反序列化的对象：" + person);
            // 注意：password为null，因为使用了transient关键字
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        serializeObject("person.dat");
        deserializeObject("person.dat");
    }
}

随机访问文件

public class RandomAccessFileDemo {
    // 使用RandomAccessFile随机读写
    public static void randomAccessFileDemo(String filePath) {
        try (RandomAccessFile raf = new RandomAccessFile(filePath, "rw")) {
            // 写入数据
            raf.writeInt(100);
            raf.writeUTF("Hello World");
            raf.writeDouble(99.99);
            // 定位到文件开头
            raf.seek(0);
            // 读取数据
            System.out.println("整数：" + raf.readInt());
            System.out.println("字符串：" + raf.readUTF());
            System.out.println("双精度：" + raf.readDouble());
            // 查看当前位置
            System.out.println("当前位置：" + raf.getFilePointer());
            System.out.println("文件长度：" + raf.length());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件属性操作

import java.nio.file.*;
import java.nio.file.attribute.*;
public class FileAttributesDemo {
    // 获取文件属性
    public static void getFileAttributes(String filePath) {
        Path path = Paths.get(filePath);
        try {
            // 基本属性
            System.out.println("文件名: " + path.getFileName());
            System.out.println("绝对路径: " + path.toAbsolutePath());
            System.out.println("父目录: " + path.getParent());
            // 文件状态
            System.out.println("是否存在: " + Files.exists(path));
            System.out.println("是文件: " + Files.isRegularFile(path));
            System.out.println("是目录: " + Files.isDirectory(path));
            // 文件属性
            BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
            System.out.println("创建时间: " + attrs.creationTime());
            System.out.println("最后修改时间: " + attrs.lastModifiedTime());
            System.out.println("文件大小: " + attrs.size() + " bytes");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

目录遍历与文件过滤

public class DirectoryDemo {
    // 遍历目录下的所有文件
    public static void listDirectory(String directoryPath) {
        File dir = new File(directoryPath);
        if (!dir.exists() || !dir.isDirectory()) {
            System.out.println("目录不存在");
            return;
        }
        // 列出所有文件和目录
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {
                String type = file.isDirectory() ? "目录" : "文件";
                System.out.println(type + ": " + file.getName() + 
                                   " (大小: " + file.length() + " bytes)");
            }
        }
    }
    // 递归遍历目录
    public static void traverseDirectory(File dir, String prefix) {
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    System.out.println(prefix + "[目录] " + file.getName());
                    traverseDirectory(file, prefix + "  ");
                } else {
                    System.out.println(prefix + "[文件] " + file.getName());
                }
            }
        }
    }
    // 文件过滤器示例
    public static void filterFiles(String directoryPath, String extension) {
        File dir = new File(directoryPath);
        // 使用FilenameFilter过滤特定类型的文件
        File[] textFiles = dir.listFiles((dir1, name) -> name.endsWith(extension));
        if (textFiles != null) {
            System.out.println("所有" + extension + "文件：");
            for (File file : textFiles) {
                System.out.println(file.getName());
            }
        }
    }
}

实用工具类

public class FileUtils {
    // 复制文件（使用NIO）
    public static void copyFileNIO(String source, String target) {
        try {
            Files.copy(Paths.get(source), Paths.get(target), 
                      StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 移动文件
    public static void moveFile(String source, String target) {
        try {
            Files.move(Paths.get(source), Paths.get(target),
                      StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件移动成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 删除文件
    public static void deleteFile(String filePath) {
        try {
            Files.deleteIfExists(Paths.get(filePath));
            System.out.println("文件删除成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 获取文件扩展名
    public static String getExtension(String fileName) {
        int dotIndex = fileName.lastIndexOf('.');
        return (dotIndex == -1) ? "" : fileName.substring(dotIndex + 1);
    }
}

使用示例

public class Main {
    public static void main(String[] args) {
        // 1. 字节流复制文件
        FileStreamDemo.copyFileByByte("source.txt", "dest.txt");
        // 2. 字符流读写
        CharStreamDemo.writeFile("test.txt", "Hello World!");
        CharStreamDemo.readFile("test.txt");
        // 3. 对象序列化
        ObjectStreamDemo.serializeObject("person.ser");
        ObjectStreamDemo.deserializeObject("person.ser");
        // 4. 文件属性
        FileAttributesDemo.getFileAttributes("test.txt");
        // 5. 目录操作
        DirectoryDemo.listDirectory(".");
        DirectoryDemo.filterFiles(".", ".txt");
        // 6. 实用方法
        FileUtils.copyFileNIO("test.txt", "test_copy.txt");
    }
}

注意事项

1. 资源管理：使用try-with-resources自动关闭流
2. 编码问题：字符流操作时注意指定编码（如UTF-8）
3. 异常处理：适当处理IOException
4. 路径问题：注意使用File.separator来处理不同系统的路径分隔符
5. 大文件处理：使用缓冲区提高效率

这些案例覆盖了Java文件流操作的核心功能,你可以根据实际需求灵活组合使用。