Wie lese ich eine große Textdatei Zeile für Zeile mit Java?

Blick auf diesen blog:

• Java Datei Lesen, Zeile für Zeile - Java Tutorial

Kann die Puffergröße angegeben werden, oder
die default-Größe verwendet werden können. Die
die Standardeinstellung ist groß genug für die meisten
Zwecke.

//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
br.close();

InformationsquelleAutor der Antwort NAVEED

Hier ist ein Beispiel mit vollständiger Fehlerbehandlung und Unterstützung charset specification for pre-Java-7. Mit Java 7 kann man mit try-mit-Ressourcen-syntax, das macht den code sauberer.

Wenn Sie wollen einfach nur die Standard-Zeichenkodierung Sie können überspringen Sie den InputStream und die Nutzung FileReader.

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

Hier ist der Groovy-version, mit voller Fehlerbehandlung:

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

InformationsquelleAutor der Antwort DarkStar

Was Sie tun können, ist, Scannen Sie den gesamten text mit Scanner und gehen Sie durch den text Zeile für Zeile.
Natürlich importieren Sie die folgenden:

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

Scanner grundsätzlich durchsucht den gesamten text. Die while-Schleife wird verwendet, um die traverse durch den gesamten text.

Den .hasNextLine() Funktion ist ein boolescher Wert, der true zurückgibt, wenn es gibt noch mehr Zeilen im text. Die .nextLine() - Funktion gibt Ihnen eine ganze Zeile als String den Sie dann verwenden können, wie Sie wollen. Versuchen System.out.println(line) den text zu drucken.

Seite Hinweis: .txt ist der Dateityp text.

InformationsquelleAutor der Antwort iskandarchacra

In Java 7:

String folderPath = "C:/folderOfMyFile";
Path path = Paths.get(folderPath, "myFileName.csv"); //or any text file eg.: txt, bat, etc
Charset charset = Charset.forName("UTF-8");

try (BufferedReader reader = Files.newBufferedReader(path , charset)) {
  while ((line = reader.readLine()) != null ) {
    //separate all csv fields into string array
    String[] lineVariables = line.split(","); 
  }
} catch (IOException e) {
    System.err.println(e);
}

InformationsquelleAutor der Antwort Diego Duarte

Für Lesen der Datei mit java 8

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

InformationsquelleAutor der Antwort Ankit Sood

Müssen Sie die readLine() Methode in class BufferedReader.
Erstellen Sie ein neues Objekt von dieser Klasse und betreiben diese Methode auf ihn zu und speichern Sie es auf einem string.

BufferReader Javadoc

InformationsquelleAutor der Antwort Master C

Den klaren Weg dies zu erreichen,

Beispiel:

Wenn Sie dataFile.txt auf Ihrem aktuellen Verzeichnis

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

Die Ausgabe wie unten

InformationsquelleAutor der Antwort RAJAMOHAN-S

Ich dokumentiert und getestet 10 verschiedene Möglichkeiten, um eine Datei Lesen im Java und dann liefen Sie gegeneinander, indem Sie Sie Lesen Sie im test-Dateien von 1KB und 1GB. Hier werden die schnellsten 3 Datei Lesen Methoden für das Einlesen einer 1GB Datei test.

Beachten Sie, dass beim ausführen des Leistungstests ich habe nicht die Ausgabe etwas zu der Konsole, da würde wirklich verlangsamen den test. Ich wollte nur den test der roh-Lesegeschwindigkeit.

1) java.nio.Datei.- Dateien.readAllBytes()

Getestet in Java 7, 8, 9. Dies war insgesamt die Schnellste Methode. Lesen einer 1-GB-Datei war durchweg knapp unter 1 Sekunde.

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.Datei.- Dateien.Linien()

Getestet wurde dies erfolgreich in Java 8 und 9, aber es funktioniert nicht in Java 7, weil der Mangel an Unterstützung für lambda-Ausdrücke. Es dauerte etwa 3,5 Sekunden Einlesen einer 1GB Datei, die Sie auf dem zweiten Platz so weit wie beim Lesen größerer Dateien.

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) BufferedReader

Getestet, um in Java 7, 8, 9. Dieser dauerte etwa 4,5 Sekunden Einlesen einer 1GB Datei test.

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

Finden Sie die kompletten rankings für alle 10-Datei Lesen Methoden hier.

InformationsquelleAutor der Antwort gomisha

Können Sie auch apache commons io:

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

InformationsquelleAutor der Antwort To Kra

Können Sie streams, es zu tun, genauer:

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

InformationsquelleAutor der Antwort spidy