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
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;
}
6
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();
}
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) {
}
};
25 回答
这基本上与耶稣拉莫斯的回答完全相同,除了 File 而不是 FileReader 加迭代以逐步浏览文件的内容 .
...抛出
FileNotFoundException
下面是以Java 8方式进行的单行程序 . 假设
text.txt
文件位于Eclipse项目目录的根目录中 .这是一个简单的解决方案:
最简单的方法是在Java和FileReader对象中使用
Scanner
类 . 简单的例子:Scanner
有几种读取字符串,数字等的方法......您可以在Java文档页面上查找有关此内容的更多信息 .例如,将整个内容读入
String
:此外,如果您需要特定的编码,可以使用此代替
FileReader
:使用BufferedReader:
缓冲流类在实践中更具性能,以至于NIO.2 API包含专门返回这些流类的方法,部分是为了鼓励您始终在应用程序中使用缓冲流 .
这是一个例子:
您可以替换此代码
同
我推荐this文章来了解Java NIO和IO的主要用途 .
我编写的这段代码对于非常大的文件要快得多:
我最喜欢读取小文件的方法是使用BufferedReader和StringBuilder . 它非常简单而且非常简单(尽管不是特别有效,但对大多数情况来说足够好):
有人指出,在Java 7之后你应该使用try-with-resources(即自动关闭)功能:
当我读这样的字符串时,我通常想要每行执行一些字符串处理,所以我就去实现这个 .
虽然如果我想实际上只是将文件读入String,我总是使用Apache Commons IO和类IOUtils.toString()方法 . 您可以在这里查看来源:
http://www.docjar.com/html/api/org/apache/commons/io/IOUtils.java.html
使用Java 7更简单:
您可以使用readAllLines和
join
方法将整个文件内容放在一行中:它默认使用UTF-8编码,正确读取ASCII数据 .
您还可以使用readAllBytes:
我认为readAllBytes更快更精确,因为它不会用
\n
替换新行,而且新行可能是\r\n
. 这取决于您的需求,哪一个适合 .如果这是关于结构的简单性,请使用Java kiss:
ASCII是一个TEXT文件,因此您可以使用Readers进行读取 . Java还支持使用InputStreams从二进制文件读取 . 如果正在读取的文件很大,那么您可能希望在FileReader之上使用BufferedReader来提高读取性能 .
关于如何使用Reader,请阅读this article
我还建议你下载并阅读这本名为Thinking In Java的精彩(但免费)的书
In Java 7 :
(docs)或
(docs)
In Java 8 :
(docs)
可能没有缓冲I / O那么快,但相当简洁:
\Z
模式告诉Scanner
分隔符是EOF .到目前为止,我还没有在其他答案中看到它 . 但如果“最佳”意味着速度,那么新的Java I / O(NIO)可能提供最快的性能,但并不总是最容易为某些人学习 .
http://download.oracle.com/javase/tutorial/essential/io/file.html
从Java中的文件读取数据的最简单方法是使用 File 类来读取文件,使用 Scanner 类来读取文件的内容 .
PS:别忘了导入java.util . *;扫描仪工作 .
Cactoos给你一个声明性的单行:
这可能不是问题的确切答案 . 这只是另一种读取文件的方法,在该文件中,您没有在Java代码中明确指定文件的路径,而是将其作为命令行参数读取 .
使用以下代码,
继续运行它:
这将读取
input.txt
的内容并将其打印到您的控制台 .您还可以通过命令行使
System.out.println()
写入特定文件,如下所示:这将从
input.txt
读取并写入output.txt
.对于基于JSF的Maven Web应用程序,只需使用ClassLoader和
Resources
文件夹读入您想要的任何文件:将要读取的任何文件放在Resources文件夹中 .
将Apache Commons IO依赖项放入您的POM:
您可以对文本文件,.properties文件,XSD模式等执行相同的操作 .
你想用文字做什么?文件是否足够小以适应内存?我会尝试找到最简单的方法来处理文件以满足您的需求 . FileUtils库非常适合这种情况 .
这是另一种不使用外部库的方法:
上面的一行可以写成1个单行:
添加到字符串构建器(如果文件很大,建议使用字符串构建器,否则使用普通字符串宾语)
我必须以不同的方式进行基准测试 . 我将评论我的发现,但简而言之,最快的方法是在FileInputStream上使用普通的旧BufferedInputStream . 如果必须读取许多文件,那么三个线程将总执行时间减少到大约一半,但是添加更多线程将逐渐降低性能,直到完成二十个线程所花费的时间比仅使用一个线程要长三倍 .
假设您必须读取文件并对其内容执行有意义的操作 . 在这些示例中,这里是从日志中读取行并计算包含超过特定阈值的值的行 . 所以我假设单行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驱动器上读取每个4 MB的204个文件的平均时间 . 这些文件是动态生成的,以避免磁盘缓存 .
我发现在SSD上运行或者SSD驱动器之间的差异比我预期的差异大约快15% . 这可能是因为文件是在未分段的HDD上生成的并且它们是顺序读取的,因此旋转驱动器几乎可以作为SSD执行 .
我对nioAsyncParse实现的低性能感到惊讶 . 要么我以错误的方式实现了某些东西,要么使用NIO实现多线程实现,并且完成处理程序执行与使用java.io API的单线程实现相同(甚至更糟) . 此外,与旧的流上的直接实现相比,具有CompletionHandler的异步解析在代码行中要长得多并且难以正确实现 .
现在六个实现后跟一个包含它们的类,加上一个可参数化的main()方法,允许使用文件数,文件大小和并发度 . 请注意,文件的大小变化加上减去20% . 这是为了避免由于所有文件大小完全相同而产生的任何影响 .
rawParse
lineReaderParse
lineReaderParseParallel
nioFilesParse
nioAsyncParse
FULL RUNNABLE IMPLEMENTATION OF ALL CASES
https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java
Guava为此提供了一个单行程:
我记录了15 ways to read a file in Java然后测试它们的速度与各种文件大小 - 从1 KB到1 GB,这里是前三种方法:
java.nio.file.Files.readAllBytes()
经测试可在Java 7,8和9中使用 .
java.io.BufferedReader.readLine()
经测试可在Java 7,8,9中使用 .
java.nio.file.Files.lines()
这被测试在Java 8和9中工作,但由于lambda表达式要求而无法在Java 7中工作 .
以下是三种工作和测试方法:
使用BufferedReader
使用扫描仪
使用FileReader
使用Scanner类在没有循环的情况下读取整个文件
org.apache.commons.io.FileUtils中的方法也可能非常方便,例如: