似乎有不同的方法来读取和写入Java中的文件数据。
我想从文件中读取ASCII数据。可能的方式和差异是什么？
答案 0 :(得分：667)
我最喜欢读取小文件的方法是使用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();
}
当我读这样的字符串时，我通常想要每行进行一些字符串处理，所以我就去实现这个。
虽然如果我想将文件读入String，我总是使用带有IOUtils.toString（）类的Apache Commons IO。您可以在这里查看来源：
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
}
答案 1 :(得分：522)
ASCII是一个TEXT文件，因此您可以使用Readers进行阅读。 Java还支持使用InputStreams从二进制文件读取。如果要读取的文件很大，那么您可能希望在BufferedReader之上使用FileReader来提高读取性能。
通过this article了解如何使用Reader
我还建议您下载并阅读这本名为Thinking In Java
的精彩（但免费）的书在Java 7中：
new String(Files.readAllBytes(...))
(docs) 或
Files.readAllLines(...)
在Java 8中：
Files.lines(..).forEach(...)
答案 2 :(得分：132)
最简单的方法是使用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)
答案 3 :(得分：75)
这是一个简单的解决方案：
String content;
content = new String(Files.readAllBytes(Paths.get("sample.txt")));
答案 4 :(得分：58)
这是另一种不使用外部库的方法：
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;
}
答案 5 :(得分：29)
我不得不对不同方式进行基准测试。我将评论我的发现，但简而言之，最快的方法是在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个文件的平均时间。这些文件是动态生成的，以避免磁盘缓存。
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上运行或者SSD驱动器之间的差异比我预期的差异大约快15％。这可能是因为文件是在未分段的HDD上生成的，并且它们是按顺序读取的，因此旋转驱动器几乎可以像SSD一样执行。
我对nioAsyncParse实现的低性能感到惊讶。要么我以错误的方式实现了某些东西，要么使用NIO实现多线程实现，并且完成处理程序执行与使用java.io API的单线程实现相同（甚至更糟）。此外，具有CompletionHandler的异步解析在代码行中要长得多，而且要比旧流上的直接实现更难实现。
现在六个实现后跟一个包含它们的类，加上一个可参数化的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<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
答案 6 :(得分：23)
以下是三种工作和测试方法：
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());
}
}
答案 7 :(得分：21)
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)
答案 8 :(得分：17)
你想对文字做什么？文件是否足够小以适应内存？我会尝试找到最简单的方法来处理文件以满足您的需求。 FileUtils库非常适合这个。
for(String line: FileUtils.readLines("my-text-file"))
System.out.println(line);
答案 9 :(得分：10)
我记录了15 ways to read a file in Java，然后测试了它们的速度，各种文件大小 - 从1 KB到1 GB，以下是执行此操作的前三种方法：
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);
}
}
}
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);
}
}
}
}
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);
});
}
}
}
答案 10 :(得分：9)
以下是以Java 8方式进行的单行程序。假设text.txt文件位于Eclipse的项目目录的根目录中。
Files.lines(Paths.get("text.txt")).collect(Collectors.toList());
答案 11 :(得分：7)
使用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();
}
答案 12 :(得分：7)
这基本上与耶稣拉莫斯的答案完全相同，除了文件而不是 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
答案 13 :(得分：6)
可能没有缓冲I / O那么快，但很简洁：
String content;
try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
content = scanner.next();
}
\Z模式告诉Scanner分隔符是EOF。
答案 14 :(得分：3)
从Java文件中读取数据的最简单方法是使用文件类来读取文件，使用扫描程序类来读取文件的内容。文件。
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。*;扫描仪工作。
答案 15 :(得分：3)
实际上，缓冲流类的性能要好得多，以至于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"));
我推荐this文章来学习Java NIO和IO的主要用途。
答案 16 :(得分：3)
到目前为止，我还没有在其他答案中提到它。但如果“最佳”意味着速度，那么新的Java I / O（NIO）可能提供最快的性能，但并不总是最容易为某些人学习。
http://download.oracle.com/javase/tutorial/essential/io/file.html
答案 17 :(得分：2)
Guava为此提供了单行代码：
import com.google.common.base.Charsets;
import com.google.common.io.Files;
String contents = Files.toString(filePath, Charsets.UTF_8);
答案 18 :(得分：2)
这可能不是问题的确切答案。它只是另一种读取文件的方式，在这种方式中，您没有在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。
答案 19 :(得分：1)
最直观的方法是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拥有数十年前的luxury！ ☺
答案 20 :(得分：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。这取决于您的需求，哪一个适合。
答案 21 :(得分：1)
Cactoos给你一个声明性的单行：
new TextOf(new File("a.txt")).asString();
答案 22 :(得分：1)
对于基于JSF的Maven Web应用程序，只需使用ClassLoader和Resources文件夹读取您想要的任何文件：
将Apache Commons IO依赖项放入您的POM：
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-io</artifactId>
<version>1.3.2</version>
</dependency>
使用下面的代码阅读它（例如下面是读取.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架构等执行相同的操作。
答案 23 :(得分：0)
如果这是关于结构的简单性，请使用Java kiss：
import static kiss.API.*;
class App {
void run() {
String line;
try (Close in = inOpen("file.dat")) {
while ((line = readLine()) != null) {
println(line);
}
}
}
}
答案 24 :(得分：0)
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。
答案 25 :(得分：0)
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();
}
答案 26 :(得分：-2)
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
添加到字符串生成器（如果文件很大，建议使用字符串生成器，否则请使用常规的String对象）
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();
}
答案 27 :(得分：-3)
我编写的这段代码对于非常大的文件来说要快得多：
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;
}