Comment lire un gros fichier texte ligne par ligne en utilisant Java?


Answers

Regardez ce blog:

La taille de la mémoire tampon peut être spécifiée ou la taille par défaut peut être utilisée. La valeur par défaut est suffisamment grande pour la plupart des cas.

// 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();
Question

J'ai besoin de lire un gros fichier texte d'environ 5-6 Go ligne par ligne en utilisant Java.

Comment puis-je le faire rapidement?




Je fais d'habitude la routine de lecture simple:

void readResource(InputStream source) throws IOException {
    BufferedReader stream = null;
    try {
        stream = new BufferedReader(new InputStreamReader(source));
        while (true) {
            String line = stream.readLine();
            if(line == null) {
                break;
            }
            //process line
            System.out.println(line)
        }
    } finally {
        closeQuiet(stream);
    }
}

static void closeQuiet(Closeable closeable) {
    if (closeable != null) {
        try {
            closeable.close();
        } catch (IOException ignore) {
        }
    }
}



Vous pouvez également utiliser 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();
}



Pour lire le fichier avec 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();
        }
        }
    }



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



Ce que vous pouvez faire est de scanner le texte entier en utilisant Scanner et de parcourir le texte ligne par ligne. Bien sûr, vous devriez importer ce qui suit:

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

Le scanner scanne tout le texte. La boucle while est utilisée pour traverser le texte entier.

La fonction .hasNextLine() est un booléen qui retourne true s'il y a encore plus de lignes dans le texte. La fonction .nextLine() vous donne une ligne entière en tant que chaîne que vous pouvez ensuite utiliser comme vous le souhaitez. Essayez System.out.println(line) pour imprimer le texte.

Side Note: .txt est le texte du type de fichier.




Vous pouvez utiliser des flux pour le faire plus précisément:

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



En Java 8, il existe également une alternative à l'utilisation de Files.lines() . Si votre source d'entrée n'est pas un fichier mais quelque chose de plus abstrait comme un Reader ou un InputStream , vous pouvez streamer les lignes via la méthode s BufferedReader lines() BufferedReader .

Par exemple:

try( BufferedReader reader = new BufferedReader( ... ) ) {
  reader.lines().foreach( line -> processLine( line ) );
}

appellera processLine() pour chaque ligne d'entrée lue par BufferedReader .




Voici un exemple avec la gestion complète des erreurs et la spécification de charset de support pour pré-Java 7. Avec Java 7, vous pouvez utiliser la syntaxe try-with-resources, ce qui rend le code plus propre.

Si vous voulez juste le jeu de caractères par défaut, vous pouvez ignorer InputStream et utiliser 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 */ } }
}

Voici la version Groovy, avec gestion complète des erreurs:

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



Le moyen clair d'y parvenir,

Par exemple:

Si vous avez dataFile.txt sur votre répertoire actuel

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

La sortie comme ci-dessous,




Related