编程马·菜鸟教程

Appearance

17.2 文件读写 ​

文件读写的概念 ​

文件读写是 Java IO 操作中的重要部分，它允许程序与文件系统进行交互，实现数据的持久化存储和读取。

文件字节流 ​

FileInputStream ​

FileInputStream 用于从文件中读取字节数据。

构造方法 ​

java
// 通过文件路径创建
FileInputStream fis = new FileInputStream("example.txt");

// 通过 File 对象创建
File file = new File("example.txt");
FileInputStream fis = new FileInputStream(file);

常用方法 ​

  • read()：读取一个字节，返回字节值（0-255），如果到达文件末尾返回 -1
  • read(byte[] b)：读取多个字节到字节数组，返回实际读取的字节数
  • read(byte[] b, int off, int len)：读取指定长度的字节到字节数组的指定位置
  • close()：关闭流

示例：使用 FileInputStream 读取文件 ​

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

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

FileOutputStream ​

FileOutputStream 用于向文件中写入字节数据。

构造方法 ​

java
// 通过文件路径创建，覆盖现有文件
FileOutputStream fos = new FileOutputStream("example.txt");

// 通过文件路径创建，追加到现有文件
FileOutputStream fos = new FileOutputStream("example.txt", true);

// 通过 File 对象创建
File file = new File("example.txt");
FileOutputStream fos = new FileOutputStream(file);

常用方法 ​

  • write(int b)：写入一个字节
  • write(byte[] b)：写入字节数组
  • write(byte[] b, int off, int len)：写入字节数组的指定部分
  • flush()：刷新流，将缓冲区中的数据写入文件
  • close()：关闭流

示例：使用 FileOutputStream 写入文件 ​

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

public class FileOutputStreamExample {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("example.txt")) {
            String content = "Hello, FileOutputStream!";
            fos.write(content.getBytes());
            System.out.println("文件写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件字符流 ​

FileReader ​

FileReader 用于从文件中读取字符数据。

构造方法 ​

java
// 通过文件路径创建
FileReader fr = new FileReader("example.txt");

// 通过 File 对象创建
File file = new File("example.txt");
FileReader fr = new FileReader(file);

常用方法 ​

  • read()：读取一个字符，返回字符值（0-65535），如果到达文件末尾返回 -1
  • read(char[] cbuf)：读取多个字符到字符数组，返回实际读取的字符数
  • read(char[] cbuf, int off, int len)：读取指定长度的字符到字符数组的指定位置
  • close()：关闭流

示例：使用 FileReader 读取文件 ​

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

public class FileReaderExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("example.txt")) {
            char[] buffer = new char[1024];
            int charsRead;
            
            while ((charsRead = fr.read(buffer)) != -1) {
                System.out.print(new String(buffer, 0, charsRead));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileWriter ​

FileWriter 用于向文件中写入字符数据。

构造方法 ​

java
// 通过文件路径创建，覆盖现有文件
FileWriter fw = new FileWriter("example.txt");

// 通过文件路径创建，追加到现有文件
FileWriter fw = new FileWriter("example.txt", true);

// 通过 File 对象创建
File file = new File("example.txt");
FileWriter fw = new FileWriter(file);

常用方法 ​

  • write(int c)：写入一个字符
  • write(char[] cbuf)：写入字符数组
  • write(char[] cbuf, int off, int len)：写入字符数组的指定部分
  • write(String str)：写入字符串
  • write(String str, int off, int len)：写入字符串的指定部分
  • flush()：刷新流，将缓冲区中的数据写入文件
  • close()：关闭流

示例：使用 FileWriter 写入文件 ​

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

public class FileWriterExample {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("example.txt")) {
            String content = "Hello, FileWriter!";
            fw.write(content);
            System.out.println("文件写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

带缓冲区的流 ​

BufferedReader ​

BufferedReader 是一个处理流，它包装了一个字符输入流，提供了缓冲功能，提高读取效率。

构造方法 ​

java
// 包装 FileReader
BufferedReader br = new BufferedReader(new FileReader("example.txt"));

常用方法 ​

  • read()：读取一个字符
  • read(char[] cbuf, int off, int len)：读取多个字符到字符数组
  • readLine()：读取一行文本
  • close()：关闭流

示例：使用 BufferedReader 读取文件 ​

java
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();
        }
    }
}

BufferedWriter ​

BufferedWriter 是一个处理流，它包装了一个字符输出流，提供了缓冲功能，提高写入效率。

构造方法 ​

java
// 包装 FileWriter
BufferedWriter bw = new BufferedWriter(new FileWriter("example.txt"));

常用方法 ​

  • write(int c)：写入一个字符
  • write(char[] cbuf, int off, int len)：写入字符数组的指定部分
  • write(String s, int off, int len)：写入字符串的指定部分
  • newLine()：写入一个换行符
  • flush()：刷新流
  • close()：关闭流

示例：使用 BufferedWriter 写入文件 ​

java
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("example.txt"))) {
            bw.write("Hello, BufferedWriter!");
            bw.newLine();
            bw.write("This is a new line.");
            System.out.println("文件写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

示例：文件复制 ​

使用字节流复制文件 ​

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

public class FileCopyExample {
    public static void main(String[] args) {
        String sourceFile = "source.txt";
        String targetFile = "target.txt";
        
        try (FileInputStream fis = new FileInputStream(sourceFile);
             FileOutputStream fos = new FileOutputStream(targetFile)) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
            
            System.out.println("文件复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用字符流复制文本文件 ​

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

public class TextFileCopyExample {
    public static void main(String[] args) {
        String sourceFile = "source.txt";
        String targetFile = "target.txt";
        
        try (BufferedReader br = new BufferedReader(new FileReader(sourceFile));
             BufferedWriter bw = new BufferedWriter(new FileWriter(targetFile))) {
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
            
            System.out.println("文本文件复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

常见问题 ​

1. 文件不存在 ​

症状：打开文件时抛出 FileNotFoundException

解决方案：确保文件路径正确，或者在写入文件时，FileOutputStream 会自动创建不存在的文件

2. 权限不足 ​

症状：打开文件时抛出 SecurityException 或 AccessDeniedException

解决方案：确保程序有足够的权限访问文件

3. 流未关闭 ​

症状：资源泄漏，可能导致文件被锁定

解决方案：使用 try-with-resources 语句自动关闭流，或在 finally 块中手动关闭流

4. 编码问题 ​

症状：读取文本文件时出现乱码

解决方案：使用 InputStreamReader/OutputStreamWriter 并指定正确的编码

最佳实践 ​

  1. 使用 try-with-resources：自动关闭流，避免资源泄漏

  2. 使用缓冲流：提高读写效率

  3. 指定编码：处理文本文件时，指定正确的编码

  4. 错误处理：捕获并处理 IOException

  5. 文件路径：使用相对路径时，注意当前工作目录

  6. 异常处理：对可能的异常进行适当的处理

总结 ​

文件读写是 Java IO 操作的重要组成部分：

  1. 字节流：

    • FileInputStream：从文件读取字节
    • FileOutputStream：向文件写入字节
    • 适用于所有类型的文件

  2. 字符流：

    • FileReader：从文件读取字符
    • FileWriter：向文件写入字符
    • 适用于文本文件

  3. 缓冲流：

    • BufferedReader：带缓冲区的字符输入流
    • BufferedWriter：带缓冲区的字符输出流
    • 提高读写效率

  4. 文件复制：

    • 使用字节流复制任意类型的文件
    • 使用字符流复制文本文件

通过合理使用这些流类，可以实现各种文件读写操作，满足不同场景的需求。

© 2026 编程马·菜鸟教程 版权所有

基于 VitePress 构建