IT技术社区_专业开发者平台_最新编程教程与解决方案 -沐辰社区

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

wen java案例 149

本文目录导读：

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文件流操作的核心功能,你可以根据实际需求灵活组合使用。

版权声明：足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播 足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播 足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播

上一篇Java文件删除案例如何实操

下一篇Java数据流案例如何读写数据

相关文章

抱歉，评论功能暂时关闭!

友情链接攻略窝 · 礼包窝 · 配置窝 · 换算窝 · 算法窝 · 查文窝 · 手册窝 · 问答窝 · 全文搜 · 手册库
相关站点礼包窝 · 查文窝