Java 文件读取全指南：如何高效地将文件内容存入数组

2026-02-10 04:17:07 0条评论 2次阅读 0人点赞

作为一名 Java 开发者，我们经常需要处理外部数据，而读取文本文件并将其内容加载到内存数组中是最基础且最常见的需求之一。虽然这听起来像是一个简单的任务，但在实际工程实践中，我们往往会面临各种选择：是使用传统的 BufferedReader，还是灵活的 Scanner？是利用 Java 8 引入的 Stream API，还是处理大文件时的分块读取？在这篇文章中，我们将深入探讨这些不同的实现方式，通过详细的代码示例和实战分析，帮助你掌握在 Java 中将文件内容读取到数组的各种技巧，并找到最适合你当前业务场景的解决方案。

为什么我们需要将文件读入数组？

在开始编码之前，让我们先明确一下应用场景。通常，我们需要将文件内容读取到数组中，是为了对数据进行批量处理、排序或快速随机访问。由于文件存储在硬盘上，属于 I/O 操作，而数组存储在内存中，这个过程本质上就是将持久化数据转化为内存数据的过程。

核心挑战：

我们在读取文件时面临的一个主要问题是，通常无法预先知道文件中究竟有多少行数据或多少个单词。数组在 Java 中是固定长度的，一旦创建就不能改变大小。为了解决这个问题，最通用的策略是“先读取后转换”：我们首先使用动态扩容的数据结构（如 ArrayList 或 List）来收集所有数据，待读取完毕后，再将其一次性转换为所需的数组类型。这既保证了读取的灵活性，又满足了最终数据结构的静态性。

为了演示接下来的代码示例，让我们假设在项目的根目录下（或者你指定的任意路径下）存在一个名为 file.txt 的文本文件，其内容如下：

Geeks,for
Geeks
Learning portal

我们将以这个文件为基础，展示四种主流的读取方法，并分析它们的优劣。

方法一：使用 BufferedReader —— 高效的字符流读取

对于大多数开发者来说，INLINECODE2b10639a 是处理文本文件的“瑞士军刀”。它不仅简单易用，而且性能出色。为什么它如此高效？因为它内部维护了一个字符缓冲区（默认通常是 8192 个字符），当我们调用 INLINECODE970f34fe 方法时，它并不是每次都去硬盘读取一个字符，而是直接从内存缓冲区中获取数据。这极大地减少了实际的磁盘 I/O 操作次数，从而提高了读取效率。

#### 代码实现与解析

下面是一个完整的示例，展示了如何使用 INLINECODE827bcffc 逐行读取文件，并将其转换为 String 数组。请注意，我们在代码中加入了详细的中文注释，并使用了 INLINECODE7aa350ed 语法来自动管理资源，防止文件句柄泄露。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ReadFileWithBufferedReader {
    public static void main(String[] args) {
        // 创建一个 List 来临时存储读取到的每一行字符串
        List listOfStrings = new ArrayList();

        // 使用 try-with-resources 语句
        // 这意味着 BufferedReader 会在 try 块执行完毕后自动关闭，无需手动调用 close()
        // 即便发生异常也能保证资源释放
        try (BufferedReader bf = new BufferedReader(new FileReader("file.txt"))) {
            
            // 读取第一行内容
            String line = bf.readLine();

            // 循环检查是否到达文件末尾（readLine() 在文件结束时返回 null）
            while (line != null) {
                // 将读取到的行添加到 List 中
                listOfStrings.add(line);
                // 继续读取下一行
                line = bf.readLine();
            }

        } catch (IOException e) {
            // 处理可能出现的 I/O 异常，例如文件不存在或读取权限问题
            e.printStackTrace();
        }

        // 将 List 转换为数组
        // 这里传入 new String[0] 是为了指定转换后的数组类型
        String[] array = listOfStrings.toArray(new String[0]);

        // 遍历数组打印内容
        for (String str : array) {
            System.out.println(str);
        }
    }
}

#### 输出结果：

Geeks,for
Geeks
Learning portal

#### 深度解析与注意事项

在这个例子中，INLINECODE3ecb25fe 方法是核心，它每次读取一行直到遇到换行符。但是，你需要注意一点：INLINECODE58469381 不会包含换行符本身。如果你需要保留换行符，可能需要手动处理。此外，我们将 INLINECODE205822c5 转换为数组时使用了 INLINECODE8ada07ef，这是一种在现代 JVM 中性能表现良好的惯用写法。

方法二：使用 Scanner —— 灵活的定界符处理

虽然 INLINECODEc397c9bf 非常适合按行读取，但如果我们需要更细粒度的控制，比如根据特定的分隔符（逗号、空格、自定义符号）来分割文件内容，INLINECODE09797ad2 类则是更好的选择。Scanner 使用正则表达式来匹配定界符，这意味着我们可以轻松地解析 CSV 文件或日志文件。

#### 代码实现与解析

下面的示例中，我们将使用 INLINECODE1fcb019d 读取文件，并指定逗号后跟可选空格（INLINECODE5188e5ba）作为分隔符。这样，文件中的 Geeks,for 将被视为两个独立的标记，而不是一行完整的字符串。

import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class ReadFileWithScanner {
    public static void main(String[] args) {
        List listOfStrings = new ArrayList();

        // 使用 try-with-resources 自动关闭 Scanner 和 FileReader
        try (Scanner sc = new Scanner(new FileReader("file.txt"))) {
            
            // 设置定界符：匹配逗号和逗号后的任意数量空白字符
            // 这里使用了正则表达式 ",\\s*"
            sc.useDelimiter(",\\s*");

            // Scanner 的 hasNext() 方法用于检查是否还有下一个标记（Token）
            while (sc.hasNext()) {
                // 获取下一个标记并添加到 List 中
                listOfStrings.add(sc.next());
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

        // 转换为数组并打印
        String[] array = listOfStrings.toArray(new String[0]);
        
        System.out.println("使用 Scanner 解析后的数组内容:");
        for (String str : array) {
            System.out.println(str);
        }
    }
}

#### 输出结果：

使用 Scanner 解析后的数组内容:
Geeks
for
Geeks
Learning portal

#### 深度解析

你会发现输出结果中，INLINECODEc588afe1 和 INLINECODE06cc3551 被分开了。这是因为 INLINECODE25bf1564 将我们定义的定界符作为了分割点。INLINECODE356a100d 的强大之处在于其灵活性，除了读取文件，它还可以直接将 INLINECODE9f2d2b76 解析为基本类型（如 INLINECODE0d1f2c20, INLINECODE4e1b82ed），这在读取格式化数据时非常有用。不过，对于单纯的大文件逐行读取，INLINECODE8a976929 的性能通常优于 Scanner。

方法三：使用 Files.readAllLines() —— 现代 Java 的一行流方案

如果你使用的是 Java 7 或更高版本，并且处理的文件不是特别大（例如几百 MB 以内），那么 INLINECODEa2a31459 包下的 INLINECODE1f60bdf0 类提供了最简洁的解决方案。INLINECODEe6ace7c9 方法会一次性读取文件中的所有行，并直接返回一个 INLINECODE23222ee0。这不仅减少了样板代码，还自动处理了字符编码（如 UTF-8）的问题。

#### 代码实现与解析

这种方法非常“干净”，非常适合快速编写脚本或中小型应用。

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class ReadFileWithNIO {
    public static void main(String[] args) {
        try {
            // 一行代码搞定所有事情：读取路径、解码、逐行读取存入 List
            // Paths.get("file.txt") 获取文件路径
            List listOfStrings = Files.readAllLines(Paths.get("file.txt"));

            // 转换为数组
            String[] array = listOfStrings.toArray(new String[0]);

            // 打印验证
            for (String str : array) {
                System.out.println(str);
            }

        } catch (IOException e) {
            System.err.println("读取文件时发生错误: " + e.getMessage());
        }
    }
}

#### 适用场景与局限性

这是最“现代”的写法。但是，你必须小心：INLINECODEfbd06ec6 会将整个文件内容一次性加载到内存中。如果你要读取一个几个 GB 大小的日志文件，这可能会导致 INLINECODE6fde2ded。因此，这种方法仅适用于内存充足且文件体积可控的场景。

方法四：使用 FileReader 结合字符数组 —— 底层精细控制

除了上述高级方法，我们还可以回归本源，直接使用 FileReader 配合字符缓冲区来读取。这种方法虽然繁琐，但能让你对读取过程拥有完全的控制权，比如你可以自定义每次读取 1024 个字符，然后手动处理换行符。这在处理某些二进制文件或非标准文本格式时非常有用。

为了完整性，我们来看一下基础的 INLINECODE558a871a 用法。虽然它不如 INLINECODE378d6029 高效（因为它没有内置缓冲），但它是理解 Java I/O 流的基础。

import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ReadFileWithFileReader {
    public static void main(String[] args) {
        List listOfStrings = new ArrayList();
        StringBuilder currentLine = new StringBuilder();

        try (FileReader fr = new FileReader("file.txt")) {
            int ch; // 存储读取到的字符（以 int 形式表示）
            
            // FileReader.read() 每次读取一个字符，如果到达末尾返回 -1
            while ((ch = fr.read()) != -1) {
                // 检查是否是换行符
                if (ch == ‘
‘) {
                    // 遇到换行符，将当前积累的一行存入 List
                    listOfStrings.add(currentLine.toString());
                    // 重置 StringBuilder 以便构建下一行
                    currentLine.setLength(0); 
                } else {
                    // 如果不是换行符，将字符追加到当前行
                    currentLine.append((char) ch);
                }
            }
            
            // 处理文件最后一行（如果文件不以换行符结尾）
            if (currentLine.length() > 0) {
                listOfStrings.add(currentLine.toString());
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

        String[] array = listOfStrings.toArray(new String[0]);
        for (String str : array) {
            System.out.println(str);
        }
    }
}

#### 为什么我们通常不直接用 FileReader？

正如你在代码中看到的，为了读取一行，我们需要手动检查每一个字符是否为换行符。这不仅代码量大，而且效率极低（因为磁盘 I/O 是以块为单位的，逐字符读取非常慢）。这就是为什么在实际开发中，我们总是习惯于将 INLINECODE30943bc9 包装在 INLINECODEb4fb7cfd 中使用的原因。

路径处理的最佳实践

在前面的例子中，我们都只写了 "file.txt"。这里有一个很重要的细节：文件路径的解析。

如果 INLINECODE145d0966 与你的 INLINECODE0a7bd531 源代码文件或者编译后的 INLINECODE70f539fc 文件在同一个目录下，直接写文件名是可以工作的。但在实际的项目结构中，情况往往更复杂。例如，在 Maven/Gradle 项目中，文件可能放在 INLINECODE2df25f18 下，或者存放在用户目录中。

#### 实用建议：

  • 使用绝对路径：明确指定 INLINECODE9d3680ba（Windows）或 INLINECODEba76e755（Linux/Mac）。这最稳妥，但可移植性差。
  • 使用相对路径：相对于“当前工作目录”的路径。你可以通过 System.getProperty("user.dir") 来打印并确认当前工作目录在哪里。
  • 使用 ClassLoader：如果文件是资源文件（放在 resources 文件夹下），最好使用 getClass().getResourceAsStream("/file.txt")，这样无论项目如何打包，都能正确读取。

总结与进阶建议

在这篇文章中，我们探讨了四种在 Java 中将文件内容读入数组的方法。作为开发者，我们应该根据具体的场景做出选择：

  • 首选 BufferedReader：对于大多数通用的文本读取任务，尤其是大文件，它是性能和代码简洁性的最佳平衡点。
  • 使用 Scanner：当你需要按特定模式或分隔符分割文本时，它是最佳工具。
  • 使用 Files.readAllLines：当文件很小且你希望代码写得像 Python 一样简洁时，选择它。
  • 避免裸用 FileReader：除非你有非常特殊的底层处理需求，否则请务必为其加上缓冲层。

#### 进阶思考：处理大文件与性能优化

如果你的任务涉及处理 GB 级别的大文件，将整个文件读入内存数组（哪怕是 List）都是危险的。这种情况下，建议使用 Java 8 的 Stream API：

try (Stream lines = Files.lines(Paths.get("large-file.txt"))) {
    lines.forEach(line -> {
        // 逐行处理，不需要将所有行同时存在内存中
        // 这里你可以对每一行进行处理，然后丢弃
        processLine(line); 
    });
}

这种方法利用了惰性求值，只有在需要时才读取和处理数据，从而极大地降低了内存消耗。

希望这篇详细的指南能帮助你更好地理解 Java 的文件 I/O 机制。动手尝试这些代码吧，你会发现看似枯燥的文件读取其实也蕴含着不少技巧和智慧！

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/41602.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年