这可能不是问题的确切答案。这只是另一种读取文件的方法，在这种方法中，您没有在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 .

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

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

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;
}

对于基于jsf的maven web应用程序，只需使用classloader和 Resources 要在任何文件中读取的文件夹：
将要读取的任何文件放在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模式等执行相同的操作。

ascii是一个文本文件，因此您可以使用 Readers 为了阅读。java还支持使用 InputStreams . 如果正在读取的文件很大，那么您应该使用 BufferedReader 在树顶上 FileReader 以提高读取性能。
通读这篇关于如何使用 Reader 我还建议您下载并阅读这本名为《java思考》的精彩（免费）书籍
在java 7中：

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

（文件）或

Files.readAllLines(...)

（文档）
在java 8中：

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

（文档）

Guava提供了一个班轮：

import com.google.common.base.Charsets;
import com.google.common.io.Files;
String contents = Files.toString(filePath, Charsets.UTF_8);

你想怎么处理这篇课文？这个文件小到可以放入内存吗？我会尽量找到最简单的方法来处理您的需要的文件。fileutils库非常适合处理这个问题。

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

到目前为止，我还没有看到其他答案中提到这一点。但是，如果“best”意味着速度，那么新的javai/o（nio）可能会提供最快的性能，但对于学习的人来说并不总是最容易理解的。
http://download.oracle.com/javase/tutorial/essential/io/file.html

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.

上述行可以写成一行：

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

其中的方法 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)

您可以使用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 . 这取决于你的需要哪一个合适。

这基本上与jesus ramos的答案完全相同，只是使用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

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

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"));

我推荐本文来学习javanio和io的主要用法。

我在java中记录了15种读取文件的方法，然后用不同的文件大小测试了它们的速度—从1 kb到1 gb和以下三种方法： java.nio.file.Files.readAllBytes() 在Java7、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()` 在Java7，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() 这在Java8和Java9中测试过，但由于lambda表达式的要求，在Java7中不起作用。

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

可能没有缓冲i/o那么快，但非常简洁：

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

这个 \Z 图案告诉我们 Scanner 分隔符是eof。