在 Java 中读取纯文本文件

Question

似乎有不同的方式来读取和写入 Java 中的文件数据。

我想从文件中读取 ASCII 数据。 有哪些可能的方式及其区别？

Answer 1

我最喜欢的读取小文件的方法是使用 BufferedReader 和 StringBuilder。 它非常简单明了（虽然不是特别有效，但对于大多数情况来说已经足够了）：

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
} finally {
    br.close();
}

有人指出，在 Java 7 之后，您应该使用try-with-resources （即自动关闭）功能：

try(BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
}

当我读到这样的字符串时，我通常想对每行进行一些字符串处理，所以我选择了这个实现。

虽然如果我实际上只是想将文件读入字符串，我总是将 Apache Commons IO与类 IOUtils.toString() 方法一起使用。 您可以在这里查看源代码：

http://www.docjar.com/html/api/org/apache/commons/io/IOUtils.java.html

FileInputStream inputStream = new FileInputStream("foo.txt");
try {
    String everything = IOUtils.toString(inputStream);
} finally {
    inputStream.close();
}

使用 Java 7 甚至更简单：

try(FileInputStream inputStream = new FileInputStream("foo.txt")) {     
    String everything = IOUtils.toString(inputStream);
    // do something with everything string
}

Answer 2

ASCII 是一个 TEXT 文件，因此您可以使用Readers进行阅读。 Java 还支持使用InputStreams从二进制文件中读取。 如果正在读取的文件很大，那么您可能希望在FileReader之上使用BufferedReader来提高读取性能。

阅读这篇关于如何使用Reader的文章

我还建议您下载并阅读这本精彩（但免费）的书，名为Thinking In Java

在 Java 7 中：

new String(Files.readAllBytes(...))

（文档）或

Files.readAllLines(...)

（文档）

在 Java 8 中：

Files.lines(..).forEach(...)

（文档）

Answer 3

最简单的方法是使用 Java 中的Scanner类和 FileReader 对象。 简单的例子：

Scanner in = new Scanner(new FileReader("filename.txt"));

Scanner有多种读取字符串、数字等的方法...您可以在 Java 文档页面上查找更多信息。

例如，将整个内容读入String ：

StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
    sb.append(in.next());
}
in.close();
outString = sb.toString();

此外，如果您需要特定的编码，您可以使用它而不是FileReader ：

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)

Answer 4

这是一个简单的解决方案：

String content = new String(Files.readAllBytes(Paths.get("sample.txt")));

或阅读为列表：

List<String> content = Files.readAllLines(Paths.get("sample.txt"))

Answer 5

这是另一种不使用外部库的方法：

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

public String readFile(String filename)
{
    String content = null;
    File file = new File(filename); // For example, foo.txt
    FileReader reader = null;
    try {
        reader = new FileReader(file);
        char[] chars = new char[(int) file.length()];
        reader.read(chars);
        content = new String(chars);
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(reader != null){
            reader.close();
        }
    }
    return content;
}

Answer 6

我必须对不同的方式进行基准测试。 我将对我的发现发表评论，但简而言之，最快的方法是在 FileInputStream 上使用普通的旧 BufferedInputStream。 如果必须读取许多文件，则三个线程会将总执行时间减少到大约一半，但添加更多线程会逐渐降低性能，直到用 20 个线程完成比只用一个线程花费的时间要长三倍。

假设您必须读取文件并对其内容做一些有意义的事情。 在此处的示例中，从日志中读取行并计算包含超过某个阈值的值的行。 所以我假设单行 Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))不是一个选项.

我在 Java 1.8、Windows 7 以及 SSD 和 HDD 驱动器上进行了测试。

我写了六个不同的实现：

rawParse ：在 FileInputStream 上使用 BufferedInputStream ，然后逐字节切割行。 这优于任何其他单线程方法，但对于非 ASCII 文件可能非常不方便。

lineReaderParse ：在 FileReader 上使用 BufferedReader，逐行读取，通过调用 String.split() 拆分行。 这比 rawParse 慢了大约 20%。

lineReaderParseParallel ：这与 lineReaderParse 相同，但它使用多个线程。 在所有情况下，这是总体上最快的选项。

nioFilesParse ：使用 java.nio.files.Files.lines()

nioAsyncParse ：使用带有完成处理程序和线程池的 AsynchronousFileChannel。

nioMemoryMappedParse ：使用内存映射文件。 这确实是一个坏主意，执行时间至少比任何其他实现长三倍。

这些是在四核 i7 和 SSD 驱动器上读取 204 个 4 MB 文件的平均时间。 这些文件是动态生成的，以避免磁盘缓存。

rawParse                11.10 sec
lineReaderParse         13.86 sec
lineReaderParseParallel  6.00 sec
nioFilesParse           13.52 sec
nioAsyncParse           16.06 sec
nioMemoryMappedParse    37.68 sec

我发现在 SSD 或 HDD 驱动器上运行的差异比我预期的要快大约 15%。 这可能是因为文件是在未分段的 HDD 上生成的，并且它们是按顺序读取的，因此旋转驱动器几乎可以像 SSD 一样运行。

我对 nioAsyncParse 实现的低性能感到惊讶。 要么我以错误的方式实现了某些东西，要么使用 NIO 和完成处理程序的多线程实现与使用 java.io API 的单线程实现执行相同（甚至更糟）。 此外，使用 CompletionHandler 的异步解析在代码行中比在旧流上的直接实现要长得多，并且难以正确实现。

现在这六个实现后面是一个包含它们的类以及一个可参数化的 main() 方法，该方法允许使用文件数量、文件大小和并发度。 请注意，文件的大小变化加上负 20%。 这是为了避免由于所有文件的大小完全相同而产生的任何影响。

原始解析

public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    overrunCount = 0;
    final int dl = (int) ';';
    StringBuffer lineBuffer = new StringBuffer(1024);
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileInputStream fin = new FileInputStream(fl);
        BufferedInputStream bin = new BufferedInputStream(fin);
        int character;
        while((character=bin.read())!=-1) {
            if (character==dl) {

                // Here is where something is done with each line
                doSomethingWithRawLine(lineBuffer.toString());
                lineBuffer.setLength(0);
            }
            else {
                lineBuffer.append((char) character);
            }
        }
        bin.close();
        fin.close();
    }
}

public final void doSomethingWithRawLine(String line) throws ParseException {
    // What to do for each line
    int fieldNumber = 0;
    final int len = line.length();
    StringBuffer fieldBuffer = new StringBuffer(256);
    for (int charPos=0; charPos<len; charPos++) {
        char c = line.charAt(charPos);
        if (c==DL0) {
            String fieldValue = fieldBuffer.toString();
            if (fieldValue.length()>0) {
                switch (fieldNumber) {
                    case 0:
                        Date dt = fmt.parse(fieldValue);
                        fieldNumber++;
                        break;
                    case 1:
                        double d = Double.parseDouble(fieldValue);
                        fieldNumber++;
                        break;
                    case 2:
                        int t = Integer.parseInt(fieldValue);
                        fieldNumber++;
                        break;
                    case 3:
                        if (fieldValue.equals("overrun"))
                            overrunCount++;
                        break;
                }
            }
            fieldBuffer.setLength(0);
        }
        else {
            fieldBuffer.append(c);
        }
    }
}

lineReaderParse

public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    String line;
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileReader frd = new FileReader(fl);
        BufferedReader brd = new BufferedReader(frd);

        while ((line=brd.readLine())!=null)
            doSomethingWithLine(line);
        brd.close();
        frd.close();
    }
}

public final void doSomethingWithLine(String line) throws ParseException {
    // Example of what to do for each line
    String[] fields = line.split(";");
    Date dt = fmt.parse(fields[0]);
    double d = Double.parseDouble(fields[1]);
    int t = Integer.parseInt(fields[2]);
    if (fields[3].equals("overrun"))
        overrunCount++;
}

lineReaderParseParallel

public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
    Thread[] pool = new Thread[degreeOfParalelism];
    int batchSize = numberOfFiles / degreeOfParalelism;
    for (int b=0; b<degreeOfParalelism; b++) {
        pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
        pool[b].start();
    }
    for (int b=0; b<degreeOfParalelism; b++)
        pool[b].join();
}

class LineReaderParseThread extends Thread {

    private String targetDir;
    private int fileFrom;
    private int fileTo;
    private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private int overrunCounter = 0;

    public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
        this.targetDir = targetDir;
        this.fileFrom = fileFrom;
        this.fileTo = fileTo;
    }

    private void doSomethingWithTheLine(String line) throws ParseException {
        String[] fields = line.split(DL);
        Date dt = fmt.parse(fields[0]);
        double d = Double.parseDouble(fields[1]);
        int t = Integer.parseInt(fields[2]);
        if (fields[3].equals("overrun"))
            overrunCounter++;
    }

    @Override
    public void run() {
        String line;
        for (int f=fileFrom; f<fileTo; f++) {
            File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
            try {
            FileReader frd = new FileReader(fl);
            BufferedReader brd = new BufferedReader(frd);
            while ((line=brd.readLine())!=null) {
                doSomethingWithTheLine(line);
            }
            brd.close();
            frd.close();
            } catch (IOException | ParseException ioe) { }
        }
    }
}

nioFilesParse

public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    for (int f=0; f<numberOfFiles; f++) {
        Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        Consumer<String> action = new LineConsumer();
        Stream<String> lines = Files.lines(ph);
        lines.forEach(action);
        lines.close();
    }
}


class LineConsumer implements Consumer<String> {

    @Override
    public void accept(String line) {

        // What to do for each line
        String[] fields = line.split(DL);
        if (fields.length>1) {
            try {
                Date dt = fmt.parse(fields[0]);
            }
            catch (ParseException e) {
            }
            double d = Double.parseDouble(fields[1]);
            int t = Integer.parseInt(fields[2]);
            if (fields[3].equals("overrun"))
                overrunCount++;
        }
    }
}

nioAsyncParse

public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
    ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
    ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<ByteBuffer>();

    for (int b=0; b<numberOfThreads; b++)
        byteBuffers.add(ByteBuffer.allocate(bufferSize));

    for (int f=0; f<numberOfFiles; f++) {
        consumerThreads.acquire();
        String fileName = targetDir+filenamePreffix+String.valueOf(f)+".txt";
        AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(fileName), EnumSet.of(StandardOpenOption.READ), pool);
        BufferConsumer consumer = new BufferConsumer(byteBuffers, fileName, bufferSize);
        channel.read(consumer.buffer(), 0l, channel, consumer);
    }
    consumerThreads.acquire(numberOfThreads);
}


class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {

        private ConcurrentLinkedQueue<ByteBuffer> buffers;
        private ByteBuffer bytes;
        private String file;
        private StringBuffer chars;
        private int limit;
        private long position;
        private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
            buffers = byteBuffers;
            bytes = buffers.poll();
            if (bytes==null)
                bytes = ByteBuffer.allocate(bufferSize);

            file = fileName;
            chars = new StringBuffer(bufferSize);
            frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            limit = bufferSize;
            position = 0l;
        }

        public ByteBuffer buffer() {
            return bytes;
        }

        @Override
        public synchronized void completed(Integer result, AsynchronousFileChannel channel) {

            if (result!=-1) {
                bytes.flip();
                final int len = bytes.limit();
                int i = 0;
                try {
                    for (i = 0; i < len; i++) {
                        byte by = bytes.get();
                        if (by=='\n') {
                            // ***
                            // The code used to process the line goes here
                            chars.setLength(0);
                        }
                        else {
                                chars.append((char) by);
                        }
                    }
                }
                catch (Exception x) {
                    System.out.println(
                        "Caught exception " + x.getClass().getName() + " " + x.getMessage() +
                        " i=" + String.valueOf(i) + ", limit=" + String.valueOf(len) +
                        ", position="+String.valueOf(position));
                }

                if (len==limit) {
                    bytes.clear();
                    position += len;
                    channel.read(bytes, position, channel, this);
                }
                else {
                    try {
                        channel.close();
                    }
                    catch (IOException e) {
                    }
                    consumerThreads.release();
                    bytes.clear();
                    buffers.add(bytes);
                }
            }
            else {
                try {
                    channel.close();
                }
                catch (IOException e) {
                }
                consumerThreads.release();
                bytes.clear();
                buffers.add(bytes);
            }
        }

        @Override
        public void failed(Throwable e, AsynchronousFileChannel channel) {
        }
};

所有案例的完全可运行的实现

https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java

Answer 7

以下是三种工作和测试方法：

使用BufferedReader

package io;
import java.io.*;
public class ReadFromFile2 {
    public static void main(String[] args)throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        BufferedReader br = new BufferedReader(new FileReader(file));
        String st;
        while((st=br.readLine()) != null){
            System.out.println(st);
        }
    }
}

使用Scanner

package io;

import java.io.File;
import java.util.Scanner;

public class ReadFromFileUsingScanner {
    public static void main(String[] args) throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        while(sc.hasNextLine()){
            System.out.println(sc.nextLine());
        }
    }
}

使用FileReader器

package io;
import java.io.*;
public class ReadingFromFile {

    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("C:\\Users\\pankaj\\Desktop\\test.java");
        int i;
        while ((i=fr.read()) != -1){
            System.out.print((char) i);
        }
    }
}

使用Scanner类无循环读取整个文件

package io;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ReadingEntireFileWithoutLoop {

    public static void main(String[] args) throws FileNotFoundException {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        sc.useDelimiter("\\Z");
        System.out.println(sc.next());
    }
}

Answer 8

org.apache.commons.io.FileUtils中的方法也可能非常方便，例如：

/**
 * Reads the contents of a file line by line to a List
 * of Strings using the default encoding for the VM.
 */
static List readLines(File file)

Answer 9

你想对文本做什么？ 文件是否足够小以适合内存？ 我会尝试找到最简单的方法来处理您需要的文件。 FileUtils 库非常适合这一点。

for(String line: FileUtils.readLines("my-text-file"))
    System.out.println(line);

Answer 10

我记录了 15 种用 Java 读取文件的方法，然后用各种文件大小测试它们的速度 - 从 1 KB 到 1 GB，以下是执行此操作的前三种方法：

1. java.nio.file.Files.readAllBytes()

   经测试可在 Java 7、8 和 9 中运行。

    import java.io.File; import java.io.IOException; import java.nio.file.Files; public class ReadFile_Files_ReadAllBytes { public static void main(String [] pArgs) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; File file = new File(fileName); byte [] fileBytes = Files.readAllBytes(file.toPath()); char singleChar; for(byte b : fileBytes) { singleChar = (char) b; System.out.print(singleChar); } } }

2. java.io.BufferedReader.readLine()

   经测试可在 Java 7、8、9 中工作。

    import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; public class ReadFile_BufferedReader_ReadLine { public static void main(String [] args) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; FileReader fileReader = new FileReader(fileName); try (BufferedReader bufferedReader = new BufferedReader(fileReader)) { String line; while((line = bufferedReader.readLine()) != null) { System.out.println(line); } } } }

3. java.nio.file.Files.lines()

   这经过测试可以在 Java 8 和 9 中工作，但由于 lambda 表达式的要求，它不能在 Java 7 中工作。

    import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.util.stream.Stream; public class ReadFile_Files_Lines { public static void main(String[] pArgs) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; File file = new File(fileName); try (Stream linesStream = Files.lines(file.toPath())) { linesStream.forEach(line -> { System.out.println(line); }); } } }

Answer 11

下面是用 Java 8 方式进行的单行代码。 假设text.txt文件位于 Eclipse 项目目录的根目录中。

Files.lines(Paths.get("text.txt")).collect(Collectors.toList());

Answer 12

缓冲流类在实践中的性能要高得多，以至于 NIO.2 API 包含专门返回这些流类的方法，部分原因是鼓励您始终在应用程序中使用缓冲流。

这是一个例子：

Path path = Paths.get("/myfolder/myfile.ext");
try (BufferedReader reader = Files.newBufferedReader(path)) {
    // Read from the stream
    String currentLine = null;
    while ((currentLine = reader.readLine()) != null)
        //do your code here
} catch (IOException e) {
    // Handle file I/O exception...
}

您可以替换此代码

BufferedReader reader = Files.newBufferedReader(path);

和

BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));

我推荐这篇文章来学习Java NIO和IO的主要用途。

Answer 13

使用 BufferedReader：

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

BufferedReader br;
try {
    br = new BufferedReader(new FileReader("/fileToRead.txt"));
    try {
        String x;
        while ( (x = br.readLine()) != null ) {
            // Printing out each line in the file
            System.out.println(x);
        }
    }
    catch (IOException e) {
        e.printStackTrace();
    }
}
catch (FileNotFoundException e) {
    System.out.println(e);
    e.printStackTrace();
}

Answer 14

这与耶稣拉莫斯的答案基本相同，除了使用File而不是FileReader加上迭代来逐步遍历文件的内容。

Scanner in = new Scanner(new File("filename.txt"));

while (in.hasNext()) { // Iterates each line in the file
    String line = in.nextLine();
    // Do something with line
}

in.close(); // Don't forget to close resource leaks

...抛出FileNotFoundException

Answer 15

Java 11 Files.readString中介绍了最直观的方法

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String args[]) throws IOException {
        String content = Files.readString(Paths.get("D:\\sandbox\\mvn\\my-app\\my-app.iml"));
        System.out.print(content);
    }
}

PHP 几十年来一直拥有这种奢侈！ ☺

Answer 16

可能不如缓冲 I/O 快，但非常简洁：

    String content;
    try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
        content = scanner.next();
    }

\Z模式告诉Scanner分隔符是 EOF。

Answer 17

在 Java 中从文件中读取数据最简单的方法是使用File类来读取文件并使用Scanner类来读取文件的内容。

public static void main(String args[])throws Exception
{
   File f = new File("input.txt");
   takeInputIn2DArray(f);
}

public static void takeInputIn2DArray(File f) throws Exception
{
    Scanner s = new Scanner(f);
    int a[][] = new int[20][20];
    for(int i=0; i<20; i++)
    {
        for(int j=0; j<20; j++)
        {
            a[i][j] = s.nextInt();
        }
    }
}

PS：别忘了导入java.util.*； 扫描仪工作。

Answer 18

您可以使用 readAllLines 和join方法在一行中获取整个文件内容：

String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));

它默认使用 UTF-8 编码，可以正确读取 ASCII 数据。

您也可以使用 readAllBytes：

String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);

我认为 readAllBytes 更快更精确，因为它不会用\n替换新行，而且新行可能是\r\n 。 这取决于您的需求，哪一个是合适的。

Answer 19

番石榴为此提供了一个单行：

import com.google.common.base.Charsets;
import com.google.common.io.Files;

String contents = Files.toString(filePath, Charsets.UTF_8);

Answer 20

这可能不是问题的确切答案。 这只是另一种读取文件的方式，您没有在 Java 代码中明确指定文件的路径，而是将其作为命令行参数读取。

使用以下代码，

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class InputReader{

    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s="";
        while((s=br.readLine())!=null){
            System.out.println(s);
        }
    }
}

继续运行它：

java InputReader < input.txt

这将读取input.txt的内容并将其打印到您的控制台。

您还可以通过命令行使您的System.out.println()写入特定文件，如下所示：

java InputReader < input.txt > output.txt

这将从input.txt读取并写入output.txt 。

Answer 21

Cactoos给你一个声明性的单行：

new TextOf(new File("a.txt")).asString();

Answer 22

到目前为止，我还没有在其他答案中看到它。 但是，如果“最佳”意味着速度，那么新的 Java I/O (NIO) 可能会提供最快的性能，但对于学习的人来说并不总是最容易理解的。

http://download.oracle.com/javase/tutorial/essential/io/file.html

Answer 23

对于基于 JSF 的 Maven Web 应用程序，只需使用 ClassLoader 和Resources文件夹来读取您想要的任何文件：

1. 将您要阅读的任何文件放入 Resources 文件夹中。

2. 将 Apache Commons IO 依赖项放入您的 POM：

    <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-io</artifactId> <version>1.3.2</version> </dependency>

3. 使用下面的代码来读取它（例如下面是读取 .json 文件）：

    String metadata = null; FileInputStream inputStream; try { ClassLoader loader = Thread.currentThread().getContextClassLoader(); inputStream = (FileInputStream) loader .getResourceAsStream("/metadata.json"); metadata = IOUtils.toString(inputStream); inputStream.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return metadata;

您可以对文本文件、.properties 文件、 XSD架构等执行相同的操作。

Answer 24

try {
  File f = new File("filename.txt");
  Scanner r = new Scanner(f);  
  while (r.hasNextLine()) {
    String data = r.nextLine();
    JOptionPane.showMessageDialog(data);
  }
  r.close();
} catch (FileNotFoundException ex) {
  JOptionPane.showMessageDialog("Error occurred");
  ex.printStackTrace();
}

Answer 25

如果这是关于结构的简单性，请使用Java Kiss ：

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}

Answer 26

import java.util.stream.Stream;
import java.nio.file.*;
import java.io.*;

class ReadFile {

 public static void main(String[] args) {

    String filename = "Test.txt";

    try(Stream<String> stream = Files.lines(Paths.get(filename))) {

          stream.forEach(System.out:: println);

    } catch (IOException e) {

        e.printStackTrace();
    }

 }

 }

只需使用 java 8 Stream。

Answer 27

如果您有一个大文件，您可以使用 Apache Commons IO 迭代地处理该文件，而不会耗尽可用内存。

try (LineIterator it = FileUtils.lineIterator(theFile, "UTF-8")) {
    while (it.hasNext()) {
        String line = it.nextLine();
        // do something with line
    }
}

Answer 28

try (Stream<String> stream = Files.lines(Paths.get(String.valueOf(new File("yourFile.txt"))))) {
    stream.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

new File(<path_name>)

通过将给定的路径名​​字符串转换为抽象路径名来创建一个新的 File 实例。 如果给定的字符串是空字符串，则结果是空的抽象路径名。 参数：路径名——路径名字符串抛出：NullPointerException——如果路径名参数为空

Files.lines返回一个字符串流

Stream<String> stream = Files.lines(Paths.get(String.valueOf(new File("yourFile.txt"))))可以抛出 nullPointerExcetion , FileNotFoundException 所以，将它保持在 try 将在运行时处理异常

stream.forEach(System.out::println);

这用于迭代流并在控制台中打印如果您有不同的用例，您可以提供自定义函数来操作行流

Answer 29

我最喜欢的从 BufferedReader 输入中读取整个文本文件的新方法是：

String text = input.lines().collect(Collectors.joining(System.lineSeparator())));

这将通过在每行后面添加新行（lineSeparator）来读取整个文件。 如果没有分隔符，它将所有行连接在一起。 这似乎自 Java 8 以来就存在。

Answer 30

对于最终来到这里的 Android 开发者（使用Kotlin的人）：

val myFileUrl = object{}.javaClass.getResource("/vegetables.txt")
val text = myFileUrl.readText() // Not recommended for huge files
println(text)

其他解决方案：

val myFileUrl = object{}.javaClass.getResource("/vegetables.txt")
val file = File(myFileUrl.toURI())
val lines = file.readLines() // Not recommended for huge files
lines.forEach(::println)

另一个也可用于大文件的好解决方案：

val myFileUrl = object{}.javaClass.getResource("/vegetables.txt")
val file = File(myFileUrl.toURI())
file
    .bufferedReader()
    .lineSequence()
    .forEach(::println)

要么：

val myFileUrl = object{}.javaClass.getResource("/vegetables.txt")
val file = File(myFileUrl.toURI())
file.useLines { lines ->
    lines.forEach(::println)
}

笔记：

• vegetables.txt文件应该在你的类路径中（例如，在src/main/resources目录中）

• 上述解决方案都默认将文件编码视为UTF-8 。 您可以将所需的编码指定为函数的参数。

• 上述解决方案不需要任何进一步的操作，例如关闭文件或阅读器。 它们由 Kotlin 标准库自动处理。

Answer 31

对于非常大的文件，我编写的这段代码要快得多：

public String readDoc(File f) {
    String text = "";
    int read, N = 1024 * 1024;
    char[] buffer = new char[N];

    try {
        FileReader fr = new FileReader(f);
        BufferedReader br = new BufferedReader(fr);

        while(true) {
            read = br.read(buffer, 0, N);
            text += new String(buffer, 0, read);

            if(read < N) {
                break;
            }
        }
    } catch(Exception ex) {
        ex.printStackTrace();
    }

    return text;
}

Answer 32

String fileName = 'yourFileFullNameWithPath';
File file = new File(fileName); // Creates a new file object for your file
FileReader fr = new FileReader(file);// Creates a Reader that you can use to read the contents of a file read your file
BufferedReader br = new BufferedReader(fr); //Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

上面的这组行可以写成 1 行：

BufferedReader br = new BufferedReader(new FileReader("file.txt")); // Optional

添加到字符串生成器（如果文件很大，建议使用字符串生成器，否则使用普通字符串对象）

try {
        StringBuilder sb = new StringBuilder();
        String line = br.readLine();

        while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
        }
        String everything = sb.toString();
        } finally {
        br.close();
    }