在Java中读取一个纯文本文件

在Java中似乎有不同的方法来读写文件数据。

我想从一个文件中读取ASCII数据。有哪些可能的方法和它们的区别？

Palec
已编辑的问题 15日 一月 2016 в 1:12
编程
java ascii file-io
17日 一月 2011 в 6:29
33 种观点
对该问题的评论 (4)

我最喜欢的读取小文件的方法是使用一个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
}
评论(12)
解决办法

ASCII是一个TEXT文件，所以你可以使用Readers来读取。Java也支持使用InputStreams从二进制文件读取。如果被读取的文件很大，那么你会想在FileReader的基础上使用BufferedReader来提高读取性能。

通过这篇文章了解如何使用 "读取器"。

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

在Java 7中。

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

(docs) 或

Files.readAllLines(...)

(docs)

在Java 8中。

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

(docs)

Lonely Neuron
编辑本段答案5日 二月 2019 в 11:21
评论(8)

最简单的方法是使用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)
评论(5)

这里有一个简单的解决方案。

String content;

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

下面是另一种不用外部库的方法。

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;
}
Peter Mortensen
编辑本段答案28日 二月 2018 в 11:20
评论(5)

我不得不对不同的方式进行基准测试。 我将对我的发现进行评论，但简而言之，最快的方式是使用普通的BufferedInputStream而不是FileInputStream。 如果必须读取许多文件，那么三个线程将使总的执行时间减少到大约一半，但增加更多的线程将逐渐降低性能，直到使使用二十个线程完成的时间是只使用一个线程的三倍。

假设你必须读取一个文件，并对其内容做一些有意义的事情。 在这里的例子中，是从一个日志中读取行，并计算其中包含超过某个阈值的值。 所以我假设单行的Java 8Files.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.filesParse。 使用java.nio.files.Files.lines()

nioAsyncParse.使用一个带有完成处理程序和线程池的异步文件通道。 使用一个异步文件通道，带有一个完成处理程序和一个线程池。

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驱动器上运行的差异比我预期的要小，SSD大约快15%。 这可能是因为文件是在无碎片的HDD上生成的，而且它们是按顺序读取的，因此旋转的硬盘几乎可以像SSD一样执行。

我对nioAsyncParse实现的低性能感到惊讶。 要么是我以错误的方式实现了某些东西，要么是使用NIO和一个完成处理程序的多线程实现的性能与使用java.io API的单线程实现相同（甚至更差）。 而且使用完成处理程序的异步解析比直接在老流上实现的代码行数要长得多，而且正确实现起来也很棘手。

现在，这六个实现之后是一个包含它们的类，再加上一个可参数化的main()方法，可以玩转文件数量、文件大小和并发程度。 请注意，文件的大小会有正负20%的变化。 这是为了避免由于所有文件的大小完全相同而造成的任何影响。

rawParse


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
评论(0)

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

使用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);
        }
    }
}

使用 "扫描器"。

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());
    }
}
评论(2)

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)
评论(3)

你想用这些文字做什么？ 文件小到可以放入内存吗？ 我会尝试找到最简单的方法来处理文件，以满足你的需求。 FileUtils 库可以很好地处理这个问题。

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

我记录了[15种在Java中读取文件的方法][1]，然后测试了它们在不同文件大小下的速度--从1 KB到1 GB，以下是三大方法。

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

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

导入java.io.File.IOException;。 import java.io.IOException; import java.nio.file.Files.Files;

公共类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()); file.toPath() for(byte b : fileBytes) { = file.toPath(); char singleChar; for(byte b : fileBytes) singleChar = (char) b; System.out.print(singleChar); } } }

  1. java.io.BufferedReader.readLine()。

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

import java.io.BufferedReader; import java.io.FileReader; import java.io.BufferedReader; import java.io.FileReader; import java.io.FileReader; import java.io.FileReader; import java.io.FileReader; import java.io.FileReader; import java.io.FileReader; import java.io.FileReader; import java.io.FileReader; import java.io.FileReader; import java.io.FileReader。 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)) { 字符串line.readLine()) != null while((line = bufferedReader.readLine()) != null) { System.out.println(line); } } } }

  1. java.nio.file.Files.lines()。

这个测试在Java 8和9中工作，但在Java 7中不能工作，因为有lambda表达式的要求。

import java.io.File.IOException; import java.io.IOException; import java.IO.IOException; import java.IO.IOException; import java.IO.IOException; import java.IO.IOException; import java.IO.IOException; import java.IO.IOException。 import java.io.IOException; import java.nio.file.Files.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); }); } } }

[1]: https://funnelgarden.com/java_read_file

Peter Mortensen
编辑本段答案27日 四月 2018 в 12:04
评论(0)

下面是用Java 8的方式做的单行本。 假设text.txt文件在Eclipse的项目目录的根目录下。

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

这基本上和Jesus Ramos&#39.的回答完全一样，只是用File代替了FileReader，再加上迭代来浏览文件内容。 答案完全一样，只是用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"。

评论(1)

使用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();
}
评论(0)

可能没有缓冲I/O的速度快，但很简洁。

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

Z模式告诉扫描器，定界符是EOF。

评论(4)

缓冲流类在实践中的性能更强，以至于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的主要用途。

Belphegor
编辑本段答案4日 十二月 2018 в 11:37
评论(0)

在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
评论(0)

到目前为止，我还没看到其他答案中提到。 但如果"Best&quot。 意味着速度，那么新的Java I/O(NIO)可能会提供最快的性能，但对于学习的人来说，并不总是最容易弄清楚。

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

评论(1)

你可以使用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`。 这取决于你的需求，哪一个是合适的。

Peter Mortensen
编辑本段答案28日 二月 2018 в 11:25
评论(0)

这可能不是问题的确切答案。 它只是另一种读取文件的方式，在这种方式下，你不在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"。

Peter Mortensen
编辑本段答案28日 二月 2018 в 11:24
评论(0)

番石榴][1]为此提供了一个单行本。

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

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

[1]: https://en.wikipedia.org/wiki/Google_Guava

评论(0)