关于性能：如何使用Java逐行读取大型文本文件？

How to read a large text file line by line using Java?

我需要使用Java来逐行读取一个大约5-6GB的大文本文件。

我怎么能这么快？

一个常见的模式是使用

1
2
3
4
5
6

try (BufferedReader br = new BufferedReader(new FileReader(file))) {
String line;
while ((line = br.readLine()) != null) {
// process the line.
}
}

如果假设没有字符编码，则可以更快地读取数据。例如，ASCII-7，但不会有太大的区别。很可能您对数据所做的操作将花费更长的时间。

编辑：一种不太常用的模式，可以避免line泄漏的范围。

1
2
3
4
5
6

try(BufferedReader br = new BufferedReader(new FileReader(file))) {
for(String line; (line = br.readLine()) != null; ) {
// process the line.
}
// line is not visible here.
}

更新：在Java 8中，你可以做

1
2
3

try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
stream.forEach(System.out::println);
}

注意：必须将流放置在Try-with资源块中，以确保对其调用Close方法，否则在GC稍后执行此操作之前，底层文件句柄永远不会关闭。

相关讨论

通过适当的异常处理，这个模式看起来是什么样的？我注意到br.close()抛出了ioexception，这看起来很奇怪——关闭一个打开以供读取的文件时会发生什么？FileReader的构造函数可能引发FileNotFound异常。
@ Java 7中的MIKEB，您将添加一个带有资源块的尝试。Close不应引发异常，但某些实现可能会引发异常。我不指望BufferedReader会使用它们。开发人员很少为close();添加特殊处理。
这是最快的Java可以走吗？我有一个大约200MB的文件，我正在用这个方法读取，它非常慢…是否可以更快地使用某些东西？多行阅读还是什么？
@Jiewmeng有很多更快的方法，但是你可以通过这种方式读取90MB/s，这样你就可以通过改变读取方式节省两秒钟的时间。如果它比那长得多，那就不是需要时间的阅读速度。
如果我有一个200MB的文件，它可以以90MB/s的速度读取，那么我希望它需要大约3秒？用这种"慢"的阅读方式，我的似乎需要几分钟的时间。我在一个固态硬盘上，所以读取速度应该不是问题？
@杰蒙，所以我怀疑你在做别的事情需要时间。你能试着读一下文件的行吗？
@彼得劳里，看起来用regex验证每行的格式是个坏主意…我有一个类似于if (line.matches(regexLineFormat))的东西，它可以加快速度。我仍然需要使用StringTokenizer来标记字符串。但现在快了很多，谢谢！
@jiewmeng您可以使用scanner或您自己的解析器，但我不在任何性能敏感的代码中使用regex。
我一直不喜欢这种常见的模式，因为当时的情况是：((line = br.readLine()) != null)。这种情况不清楚。
@亚历克斯，如果你不明白的话，我不会用的。不过，你可能会发现，另一种选择已经不太清楚了。；)
为什么不使用EDOCX1？7？BTW，在Java 8中，你可以做EDOCX1，8，这是很难不讨厌的。
AleksandrDubinsky，我在Java 8的闭包中遇到的问题是，它很容易使代码读起来更复杂(也比较慢)。我可以看到很多开发人员过度使用它，因为它很酷。
你确实抓住了"仇恨"的部分，对吧？：)尽管实际上我没有使用闭包/lambda。
@aleksandrdubinsky我很高兴在有意义的地方使用闭包。我看到的关于闭包的大多数例子都很简单，不使用闭包会更好、更简单。
@Peterlawrey你好，Peter，添加新的Java-8功能来快速、清晰地读取文件是很有趣的：)
@Yassinhajaj同意，前提是使用lambda使代码更容易阅读。如果过度使用它们会使阅读变得困难。我们把我们的第一个主要应用程序写在Java 2014中(26000行代码，其中大部分使用流)，我们发现在某些情况下，使用传统的循环是更干净的，当你正在改变数据，当你去，或生产/更新一个以上的集合，例如。
@ YassinHajaj，这是一个很好的建议，我已经为Java 8添加了一个示例。这并不像看上去那么简单。；)+ 1
@是的，谢谢你的编辑和信息。好吧，我的意思是写得快：)但是如果你经历过一些性能问题，我可以相信你：)
@Yassinhajaj我的意思是，在需要资源的尝试中有一个难题。
PeterLawrey，这是一个很好的答案，但在我看来，作为大多数投票的答案，你应该注意到你的解决方案只适用于Java 7或更高版本。仍然有很多人使用Java 5(或最坏)，这不能从资源特性的尝试中获益。
艾伯特，我认为即使是那些不能编写Java 7的人也可以读取Java 7，并且知道在完成它之后如何关闭文件。我不认为人们知道如何读取Java 8，但复古适合流/lambdas。；)
@Aboozarajabi你所说的"不工作"是什么意思？你还有什么问题？
JavaLang.OutOfMeMyLogError：Java堆空间
@Aboozarajabi如果你有很长的行和很小的内存，你可能需要一次只处理一行，或者一次只处理一行的一部分。如果运行上面的示例，您会得到OOME，还是在处理这些行时得到OOME？也就是说，OOME是否出现在您的代码中？
有这么多行，文件大约1吉格，但每行都很短。当我试图用这段代码读取文件并只打印其中的每一个代码时，我很惊讶。
@在这种情况下，我将使用BufferedReader循环。
比如下面的答案？
@Aboozarajabi我认为我的答案更清楚，因为它使用了Try with Resource。看我答案的第二行。
同样的问题，即使当我增加Java堆大小！
@Aboozarajabi这一次只有一条线，所以如果你有一个OOME，你会有一条很长的线，因为这就是所有被保留的。
当我将它用于较短的文件(300MB)时，它是可以的，但是对于1.5g的文件，我会得到OOME错误。
@Aboozarajabi要使BufferedReader发生这种情况，您必须将数据保留在某个地方，否则只有行长度才重要。
小心使用Java 8文件.LIVES()方法。它以不同的方式处理字符编码。BufferedReader很宽大，可以处理非utf8字符而不必担心，但是file.lines()遇到非utf8字符时会抛出异常。如果不是默认的UTF-8，则必须使用files.lines()指定所需的字符编码。

看看这个博客：

Java读取文件逐行-Java教程

The buffer size may be specified, or
the default size may be used. The
default is large enough for most
purposes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Open the file
FileInputStream fstream = new FileInputStream("textfile.txt");
BufferedReader br = new BufferedReader(new InputStreamReader(fstream));

String strLine;

//Read File Line By Line
while ((strLine = br.readLine()) != null) {
// Print the content on the console
System.out.println (strLine);
}

//Close the input stream
fstream.close();

相关讨论

一旦java-8退出(2014年3月)，您就可以使用流：

1
2
3

try (Stream<String> lines = Files.lines(Paths.get(filename), Charset.defaultCharset())) {
lines.forEachOrdered(line -> process(line));
}

打印文件中的所有行：

1
2
3

try (Stream<String> lines = Files.lines(file, Charset.defaultCharset())) {
lines.forEachOrdered(System.out::println);
}

相关讨论

这里有一个完整的错误处理和支持Java 7的字符集规范的示例。使用Java 7，可以使用"尝试资源"语法，这使得代码更干净。

如果只需要默认字符集，可以跳过输入流并使用FileReader。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

InputStream ins = null; // raw byte-stream
Reader r = null; // cooked reader
BufferedReader br = null; // buffered for readLine()
try {
String s;
ins = new FileInputStream("textfile.txt");
r = new InputStreamReader(ins,"UTF-8"); // leave charset out for default
br = new BufferedReader(r);
while ((s = br.readLine()) != null) {
System.out.println(s);
}
}
catch (Exception e)
{
System.err.println(e.getMessage()); // handle exception
}
finally {
if (br != null) { try { br.close(); } catch(Throwable t) { /* ensure close happens */ } }
if (r != null) { try { r.close(); } catch(Throwable t) { /* ensure close happens */ } }
if (ins != null) { try { ins.close(); } catch(Throwable t) { /* ensure close happens */ } }
}

下面是groovy版本，具有完整的错误处理：

1
2
3
4
5
6

File f = new File("textfile.txt");
f.withReader("UTF-8") { br ->
br.eachLine { line ->
println line;
}
}

相关讨论

在Java 8中，您可以这样做：

1
2
3
4
5
6
7

try (Stream<String> lines = Files.lines (file, StandardCharsets.UTF_8))
{
for (String line : (Iterable<String>) lines::iterator)
{
;
}
}

一些注意事项：Files.lines返回的流(与大多数流不同)需要关闭。由于这里提到的原因，我避免使用forEach()。奇怪的代码(Iterable) lines::iterator将流投射到一个不可测的对象。

相关讨论

你能做的就是用扫描仪扫描整个文本，然后一行一行地浏览文本。当然，您应该导入以下内容：

1
2
3
4
5
6
7
8
9
10

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public static void readText throws FileNotFoundException {
Scanner scan = new Scanner(new File("samplefilename.txt"));
while(scan.hasNextLine()){
String line = scan.nextLine();
//Here you can manipulate the string the way you want
}
}

扫描器基本上扫描所有文本。while循环用于遍历整个文本。

.hasNextLine()函数是一个布尔值，如果文本中还有更多行，则返回true。.nextLine()函数为您提供了一整行字符串，然后您可以使用所需的方式。尝试使用System.out.println(line)打印文本。

旁注：.txt是文件类型文本。

相关讨论

FileReader不允许您指定编码，如果需要指定编码，请使用InputStreamReader：

1
2
3
4
5
6
7
8
9
10
11
12

try {
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"Cp1252"));

String line;
while ((line = br.readLine()) != null) {
// process the line.
}
br.close();

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

如果您从Windows导入此文件，它可能具有ANSI编码(CP1252)，因此您必须指定编码。

相关讨论

在Java 7中：

相关讨论

我记录并测试了10种不同的方法来读取Java中的文件，然后通过使它们在1KB到1GB的测试文件中读取来运行它们。以下是读取1GB测试文件最快的3种文件读取方法。

请注意，在运行性能测试时，我没有向控制台输出任何内容，因为这会真正降低测试的速度。我只是想测试一下原始的阅读速度。

1)Java.Nio.Field.FraseByTySe()

在Java 7, 8, 9中进行测试。这是最快的方法。读取一个1GB文件的时间总是不到1秒。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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-1GB.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.Nio.Field.Fix.LISE()

这是在Java 8和9中成功测试的，但是由于缺少对lambda表达式的支持，它在Java 7中不起作用。在一个1GB文件中读取大约需要3.5秒，这使得它在读取较大的文件时位居第二。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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-1GB.txt";
File file = new File(fileName);

try (Stream linesStream = Files.lines(file.toPath())) {
linesStream.forEach(line -> {
System.out.println(line);
});
}
}
}

3)缓冲读卡器

测试在Java 7, 8, 9中工作。读取一个1GB测试文件大约需要4.5秒。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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-1GB.txt";
FileReader fileReader = new FileReader(fileName);

try (BufferedReader bufferedReader = new BufferedReader(fileReader)) {
String line;
while((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
}
}

您可以在这里找到所有10种文件读取方法的完整排名。

相关讨论

用Java 8读取文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package com.java.java8;

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

/**
* The Class ReadLargeFile.
*
* @author Ankit Sood Apr 20, 2017
*/
public class ReadLargeFile {

/**
* The main method.
*
* @param args
* the arguments
*/
public static void main(String[] args) {
try {
Stream<String> stream = Files.lines(Paths.get("C:\\Users\\System\\Desktop\\demoData.txt"));
stream.forEach(System.out::println);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

您可以使用scanner类

1 2	Scanner sc=new Scanner(file); sc.nextLine();

相关讨论

在Java 8中，还有一种使用EDCOX1(8)的替代方案。如果输入源不是文件，而是更抽象的东西，比如Reader或InputStream，则可以通过BufferedReader的lines()方法来传输行。

例如：

1
2
3

try (BufferedReader reader = new BufferedReader(...)) {
reader.lines().foreach(line -> processLine(line));
}

对于由BufferedReader读取的每个输入行，将调用processLine()。

您需要在class BufferedReader中使用readLine()方法。从该类创建一个新对象，并对其操作此方法并将其保存到字符串中。

BufferReader JavaDoc

相关讨论

JAVA－9：

1
2
3

try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
stream.forEach(System.out::println);
}

相关讨论

实现这一目标的明确方法，

例如：

如果您当前目录中有dataFile.txt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

public class readByLine
{
public readByLine() throws FileNotFoundException
{
Scanner linReader = new Scanner(new File("dataFile.txt"));

while (linReader.hasNext())
{
String line = linReader.nextLine();
System.out.println(line);
}
linReader.close();

}

public static void main(String args[]) throws FileNotFoundException
{
new readByLine();
}
}

输出如下： enter image description here

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

BufferedReader br;
FileInputStream fin;
try {
fin = new FileInputStream(fileName);
br = new BufferedReader(new InputStreamReader(fin));

/*Path pathToFile = Paths.get(fileName);
br = Files.newBufferedReader(pathToFile,StandardCharsets.US_ASCII);*/

String line = br.readLine();
while (line != null) {
String[] attributes = line.split(",");
Movie movie = createMovie(attributes);
movies.add(movie);
line = br.readLine();
}
fin.close();
br.close();
} catch (FileNotFoundException e) {
System.out.println("Your Message");
} catch (IOException e) {
System.out.println("Your Message");
}

它对我有用。希望它也能帮助你。

我通常把阅读程序做得很简单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

void readResource(InputStream source) throws IOException {
BufferedReader stream = null;
try {
stream = new BufferedReader(new InputStreamReader(source));
while (true) {
String line = stream.readLine();
if(line == null) {
break;
}
//process line
System.out.println(line)
}
} finally {
closeQuiet(stream);
}
}

static void closeQuiet(Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
} catch (IOException ignore) {
}
}
}

您可以使用流进行更精确的操作：

1	Files.lines(Paths.get("input.txt")).forEach(s -> stringBuffer.append(s);

相关讨论

通过使用Or.ApAC.E.MuleS.IO包提供了更多的性能，特别是在使用Java 6和以下的遗留代码中。Java7有更好的API，例外更少。处理和更有用的方法

1
2
3
4
5
6
7
8
9
10

LineIterator lineIterator =null;
try{
lineIterator = FileUtils.lineIterator(new File("/home/username/m.log"),"windows-1256");//second parameter is optionanl
while (lineIterator.hasNext()){
String currentLine = lineIterator.next();
//some operation
}
}finally {
LineIterator.closeQuietly(lineIterator);
}

马文

1
2
3
4
5
6

<dependency>
<groupId>commons-io</groupId>
commons-io</artifactId>
<version>2.6</version>
</dependency>

您可以使用此代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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

public class ReadTextFile {

public static void main(String[] args) throws IOException {

try {

File f = new File("src/com/data.txt");

BufferedReader b = new BufferedReader(new FileReader(f));

String readLine ="";

System.out.println("Reading file using Buffered Reader");

while ((readLine = b.readLine()) != null) {
System.out.println(readLine);
}

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

}

}

您也可以使用apache commons io：

1
2
3
4
5
6
7

File file = new File("/home/user/file.txt");
try {
List<String> lines = FileUtils.readLines(file);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

相关讨论