Czytanie zwykłego pliku tekstowego w Javie

Moim ulubionym sposobem odczytu małego pliku jest użycie Bufferedreadera i Stringbuildera. Jest to bardzo proste i do rzeczy (choć nie szczególnie skuteczne, ale wystarczająco dobre dla większości przypadków): {]}

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

Niektórzy zauważyli, że po Javie 7 należy używaćtry-with-resources (tj. auto close) funkcji:

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

Kiedy czytam ciągi takie jak ten, zazwyczaj chcę wykonać jakąś obsługę ciągów w każdym wierszu, więc idę do tej implementacji.

Choć jeśli chcesz po prostu wczytać plik w łańcuch, zawsze używam Apache Commons IO z klasą IOUtils.metoda toString (). Możesz spojrzeć na źródło tutaj:

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

I jeszcze prostsze z Java 7:

try(FileInputStream inputStream = new FileInputStream("foo.txt")) {     
    String everything = IOUtils.toString(inputStream);
    // do something with everything string
}

Najprostszym sposobem jest użycie klasy Scanner w Javie i obiektu FileReader. Prosty przykład:

Scanner in = new Scanner(new FileReader("filename.txt"));

Scanner posiada kilka metod odczytu w łańcuchach, liczbach, itp... Więcej informacji na ten temat można znaleźć na stronie dokumentacji Java.

Na przykład odczytanie całej treści do String:

StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
    sb.append(in.next());
}
in.close();
outString = sb.toString();

Również jeśli potrzebujesz określonego kodowania, możesz użyć tego zamiast FileReader:

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)

Oto proste rozwiązanie:

String content;

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

Oto inny sposób, aby to zrobić bez użycia zewnętrznych bibliotek:

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

Musiałem porównać różne sposoby. Skomentuję moje ustalenia, ale krótko mówiąc, najszybszym sposobem jest użycie zwykłego starego BufferedInputStream nad strumieniem plików. Jeśli trzeba odczytać wiele plików, to trzy wątki skracają całkowity czas wykonania do około połowy, ale dodawanie kolejnych wątków stopniowo obniża wydajność, aż do momentu, gdy ukończenie dwudziestu wątków zajmie trzy razy więcej czasu niż tylko jeden wątek.

Zakłada się, że musisz przeczytać plik i zrobić coś znaczącego z jego zawartością. W przykładach tutaj jest odczyt linii z dziennika i policzyć te, które zawierają wartości, które przekraczają pewien próg. Zakładam więc, że Jednowierszowa Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) nie wchodzi w grę.

Napisałem sześć różnych implementacji:

RawParse : użyj BufferedInputStream nad strumieniem plików, a następnie wytnij linie czytające bajt po bajcie. To przerosło wszelkie inne podejście jednowątkowe, ale może być bardzo niewygodne dla plików innych niż ASCII.

LineReaderParse : używa programu BufferedReader nad programem FileReader, czyta linię po linii, dzieli linie przez wywołanie String.split (). Jest to około 20% wolniejsze niż rawParse.

LineReaderParseParallel: jest to to samo co lineReaderParse, ale używa kilku wątków. Jest to najszybsza opcja ogólnie we wszystkich przypadkach.

NioFilesParse : Użycie java.nio.pliki.Pliki.lines ()

NioAsyncParse: używa AsynchronousFileChannel z obsługą zakończenia i pulą wątków.

NioMemoryMappedParse: Użyj pliku mapowanego pamięcią. Jest to naprawdę zły pomysł, dając czas wykonania co najmniej trzy razy dłuższy niż jakakolwiek inna implementacja.

Są to średnie czasy odczytu 204 plików po 4 MB każdy na czterordzeniowym dysku i7 i SSD. Pliki są generowane w locie, aby uniknąć dysku buforowanie.

rawParse                11.10 sec
lineReaderParse         13.86 sec
lineReaderParseParallel  6.00 sec
nioFilesParse           13.52 sec
nioAsyncParse           16.06 sec
nioMemoryMappedParse    37.68 sec

Znalazłem mniejszą niż się spodziewałem różnicę między uruchomieniem na dysku SSD lub dysku twardym, który jest SSD o około 15% szybszy. Może to być spowodowane tym, że pliki są generowane na niefragmentowanym dysku twardym i są odczytywane kolejno, dlatego dysk wirujący może działać prawie jak dysk SSD.

Byłem zaskoczony niską wydajnością implementacji nioAsyncParse. Albo zaimplementowałem coś w niewłaściwy sposób, albo implementacja wielowątkowa przy użyciu NIO i obsługa zakończenia wykonuje to samo (lub nawet gorzej) niż implementacja jednowątkowa z java.io API. Co więcej, asynchroniczny parse z CompletionHandler jest znacznie dłuższy w wierszach kodu i trudny do poprawnego zaimplementowania niż prosta implementacja na starych strumieniach.

Teraz sześć implementacji, a następnie Klasa zawierająca je wszystkie plus parametryzowalna metoda main (), która pozwala na odtwarzanie z liczbą plików, rozmiarem pliku i stopniem współbieżności. Zauważ, że rozmiar plików zmienia się plus minus 20%. Ma to na celu uniknięcie efektu ze względu na to, że wszystkie pliki mają dokładnie ten sam rozmiar.

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

PEŁNA REALIZACJA WSZYSTKICH Przypadki

Https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java

Metody wewnątrz org.apache.commons.io.FileUtils może być również bardzo przydatny, np.:

/**
 * 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)

Oto trzy metody pracy i przetestowane:

Użycie 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);
        }
    }
}

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

Używanie 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);
        }
    }
}

Odczyt całego pliku bez pętli za pomocą klasy 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());
    }
}

Co chcesz zrobić z tekstem? Czy plik jest wystarczająco mały, aby zmieścić się w pamięci? Postaram się znaleźć najprostszy sposób obsługi pliku dla Twoich potrzeb. Biblioteka FileUtils jest do tego bardzo przydatna.

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

Poniżej znajduje się jednolinijkowy sposób robienia tego w Javie 8. Zakładając, że plik text.txt znajduje się w katalogu głównym projektu Eclipse.

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

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

Jest to w zasadzie dokładnie to samo, co odpowiedź Jezusa Ramosa, z wyjątkiem File zamiast FileReader plus iteracja, aby przejść przez zawartość pliku.

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

... rzuty FileNotFoundException

Prawdopodobnie nie tak szybko jak z buforowanymi We / Wy, ale dość zwięźle:

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

Wzór \Z mówi Scanner, że ogranicznikiem jest EOF.

Udokumentowałem 15 sposobów odczytu pliku w Javie , a następnie przetestowałem je pod kątem szybkości z różnymi rozmiarami plików - od 1 KB do 1 GB i oto trzy najlepsze sposoby na to:

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

   Testowany do pracy w Javie 7, 8 i 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);
       }
     }
   }
   

2. java.io.BufferedReader.readLine()

   Testowany do pracy w Javie 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);
         }
       }
     }
   }
   

3. java.nio.file.Files.lines()

   To zostało przetestowane do pracy w Javie 8 i 9, ale nie będzie działać w Javie 7 z powodu wyrażenia lambda wymagania.

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

Nie widzę tego jeszcze w innych odpowiedziach do tej pory. Ale jeśli "Najlepsze" oznacza szybkość, to nowe wejścia/wyjścia Java (NIO) mogą zapewnić najszybszą preformancję, ale nie zawsze najłatwiejszą do znalezienia dla kogoś uczącego się.

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

Najprostszym sposobem odczytu danych z pliku w Javie jest użycie klasy File do odczytu pliku oraz klasy Scanner do odczytu zawartości pliku.

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: nie zapomnij zaimportować Javy.util.* ; do pracy skanera.

To może nie być dokładna odpowiedź na to pytanie. Jest to po prostu inny sposób odczytu pliku, w którym nie określa się jawnie ścieżki do pliku w kodzie Java, a zamiast tego odczytuje się go jako argument wiersza poleceń.

Z następującym kodem,

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

Po prostu uruchom go z:

java InputReader < input.txt

To odczytałoby zawartość input.txt i wydrukowałoby ją na konsoli.

Możesz również sprawić, że System.out.println() zapisze się do określonego pliku za pomocą polecenia wiersz w następujący sposób:

java InputReader < input.txt > output.txt

To będzie czytać z input.txt i pisać do output.txt.

Dla aplikacji internetowych Maven opartych na JSF, wystarczy użyć Classloadera i folderu Resources, aby przeczytać w dowolnym pliku:

1. Umieść dowolny plik, który chcesz przeczytać w folderze zasoby.

2. Umieść zależność Apache Commons IO w Twoim POM:

   <dependency>
       <groupId>org.apache.commons</groupId>
       <artifactId>commons-io</artifactId>
       <version>1.3.2</version>
   </dependency>
   

3. Użyj poniższego kodu, aby go odczytać (np.plik 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;
   

Możesz zrobić to samo dla plików tekstowych, .pliki właściwości, Schematy XSD itp.

Guawa zapewnia do tego jedną warstwę:

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

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

Cactoos daje deklaratywną jednowierszową:

new TextOf(new File("a.txt")).asString();

Możesz użyć readAllLines i metody join, aby uzyskać całą zawartość pliku w jednej linii:

String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));

Domyślnie używa kodowania UTF-8, które poprawnie odczytuje dane ASCII.

Możesz również użyć readAllBytes:

String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);

Myślę, że readAllBytes jest szybszy i bardziej precyzyjny, ponieważ nie zastępuje nowej linii \n, a także nową linią może być \r\n. To w zależności od potrzeb, który z nich jest odpowiedni.

Użyj Java kiss jeśli chodzi o prostotę struktury:

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}

Buforowane klasy strumienia są znacznie bardziej wydajne w praktyce, tak bardzo, że NIO.2 API zawiera metody, które zwracają te klasy strumieni, po części zachęcając do korzystania ze strumieni buforowanych w aplikacji.

Oto przykład:

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

Możesz zastąpić ten kod

BufferedReader reader = Files.newBufferedReader(path);

Z

BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));

Polecam ten artykuł , aby poznać główne zastosowania Javy NIO i IO.

Ten kod, który zaprogramowałem jest znacznie szybszy dla bardzo dużych plików:

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