Comment lire un gros fichier texte ligne par ligne à l'aide de Java?

J'ai besoin de lire un texte de grande taille de fichier d'environ 5-6 GO ligne par ligne à l'aide de Java.

Comment puis-je le faire rapidement?

et. al. Cette question ne doit pas être marqué comme un doublon. "Vite lu la dernière ligne" n'est pas une alternative, et de son droit de se demander si "le moyen le plus Rapide pour lire fichier texte ligne par ligne" est. Le moyen le plus rapide pour faire quelque chose n'est pas nécessairement la façon la plus commune. En outre, les réponses ci-dessous incluent le code, la plupart des alternatives pertinentes vous de la liste ne pas. Cette question est utile. Il est actuellement le plus de résultats de recherche google pour "java lire le fichier ligne par ligne". Enfin, sa mise hors d'arriver à un débordement de pile et de trouver que 1 personne sur 2 est marqué pour l'élimination.
Ici c'est une comparaison de la vitesse pour six implémentations possibles.
L'évènement, j'ai lu des commentaires affirmant que c'est TELLEMENT proche de la politique suce, DONC persiste en elle. C'est un esprit étroit point de vue développeur de vouloir éviter la redondance au niveau de tous les coûts! Juste que ce soit! La crème va monter vers le haut et le sh*t va couler au fond de l'amende juste par lui-même. Même si une question a pu être posée avant (la question n'est-ce pas??), cela ne signifie pas qu'une nouvelle question peut ne pas être en mesure de l'exprimer mieux, obtenir des réponses de meilleure qualité, rang plus élevé dans les moteurs de recherche etc. Fait intéressant, cette question est maintenant de "protégé"....
C'est incroyable comment les questions marqués comme en double juste en lisant le titre.

InformationsquelleAutor manoj singh | 2011-05-03

file-io garbage-collection io java java-8 performance

988

Un modèle commun est d'utiliser
```
try (BufferedReader br = new BufferedReader(new FileReader(file))) {
    String line;
    while ((line = br.readLine()) != null) {
       //process the line.
    }
}
```
Vous pouvez lire les données plus rapidement si vous assumez il n'y a pas de codage de caractères. par exemple ASCII-7, mais il ne fera pas beaucoup de différence. Il est très probable que ce que vous faites avec les données prendra beaucoup plus de temps.

EDIT: UNE commune de moins de motif, ce qui évite le champ d'application de line fuite.
```
try(BufferedReader br = new BufferedReader(new FileReader(file))) {
    for(String line; (line = br.readLine()) != null; ) {
        //process the line.
    }
    //line is not visible here.
}
```
Mise à JOUR: En Java 8, vous pouvez faire
```
try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
        stream.forEach(System.out::println);
}
```
REMARQUE: Vous devez placer le Ruisseau dans une essayez-avec-des ressources block pour s'assurer que le #fermer méthode est appelée sur elle, sinon, le fichier sous-jacent de la poignée n'est jamais fermée jusqu'à ce que GC n'est que bien plus tard.
- Qu'est-ce modèle ressemble avec une bonne gestion des exceptions? Je remarque que le br.close() throws IOException, ce qui semble surprenant -- ce qui pourrait se produire lors de la fermeture d'un fichier est ouvert pour lire, de toute façon? FileReader du constructeur pourrait jeter un FileNotFound exception.
- Dans Java 7 vous souhaitez ajouter un try-with-ressource bloc. Proche n'est pas prévu de lancer une exception, mais certaines implémentations peuvent. Je ne m'attends pas BufferedReader est sur d'eux. Il est très rare de voir des développeurs d'ajouter un traitement spécial pour close();
- Est-ce le plus rapide Java peut aller? J'ai un ~200 MO de fichier je suis à lire avec cette méthode et c'est vraiment lent ... est-il possible d'utiliser quelque chose de plus rapide? Lu dans plusieurs lignes ou quelque chose?
- Il est beaucoup plus rapide des moyens de le faire, cependant, vous pouvez lire 90 MO/s de cette façon, de sorte que vous pouvez enregistrer deux secondes en changeant la façon dont vous le lire. Si c'est beaucoup plus que cela, ce n'est pas la vitesse de lecture est de prendre le temps.
- Si j'ai un fichier de 200 mo et il peut lire à 90 MO/s, puis-je espérer qu'il prendra ~3s? Les miens semblent prendre de quelques minutes, avec cette "lente" manière de lire. Je suis sur un SSD, donc des vitesses de lecture ne devrait pas être un problème?
- DONC je soupçonne autre chose que vous faites est de prendre le temps. Pouvez-vous essayer il suffit de lire les lignes du fichier et rien else.
- ressemble à de la validation du format de chaque ligne avec la regex est une mauvaise idée ... j'avais quelque chose comme if (line.matches(regexLineFormat)) retrait qui a accéléré les choses beaucoup. J'ai encore besoin d'utiliser StringTokenizer pour marquer la chaîne. Mais son beaucoup plus vite maintenant, merci!
- Vous pouvez utiliser le Scanner ou de votre propre analyseur peut-être, mais je ne suis pas d'utiliser des regex dans toute la performance sensible code.
- J'ai toujours détester ce modèle commun en raison de la condition du while: ((line = br.readLine()) != null). Cette condition est pas effacer.
- dans ce cas, je ne voudrais pas l'utiliser si vous ne pensez pas que c'est clair. Vous pouvez trouver l'alternative n'est pas plus clair pour autant. 😉
- Pourquoi ne pas for(String line = br.readLine(); line != null; line = br.readLine()) Btw, dans Java 8, vous pouvez faire try( Stream<String> lines = Files.lines(...) ){ for( String line : (Iterable<String>) lines::iterator ) { ... } } Qui est difficile de ne pas la haine.
- Le problème que j'ai avec fermetures en Java 8 est qu'il est très facile de rendre le code plus compliqué à lire (et lent) je peux voir beaucoup de développeurs abuser parce que c'est "cool".
- Vous n'avez attraper la "haine" de la partie, non? 🙂 Même si en fait je n'ai pas utilisé fermetures/lambdas.
- Je suis heureux d'utiliser les fermetures où ils font sens. La plupart des exemples que je vois pour les fermetures sont aussi triviale, il serait mieux, plus simple de ne pas utiliser de dispositifs de fermeture.
- Salut Pierre, il serait amusant d'ajouter le nouveau java-8 fonctionnalités de lecture d'un fichier rapide et propre 🙂
- convenu, à condition que les lambdas sont utilisés pour rendre le code plus facile à lire. Ils peuvent rendre plus difficile à lire si plus utilisé. Nous mettons notre première grande application écrite en Java 8 en 2014 (de 26 000 lignes de code, une grande partie de l'aide de cours d'eau), et nous avons constaté, dans certains cas, à l'aide d'un traditionnel boucle était plus propre lorsque vous êtes à la mutation de données que vous allez, ou de la production/mise à jour plus d'une des collections par exemple.
- c'est une bonne idée et j'ai ajouté un exemple pour Java 8. Ce n'est pas aussi simple qu'il puisse paraître. 😉 +1
- Yep, merci pour le modifier et de l'info. Eh bien j'ai fait rapide dans les termes de l'écrire 🙂 Mais je peux vous faire confiance si vous avez eu certains problèmes de performances 🙂
- Je voulais dire, il y a une chasse aux sorcières dans avoir besoin de l'essayer avec des ressources
- c'est une bonne réponse, mais à mon avis, car la plupart ont voté réponse de loin, vous devriez prendre note que votre solution ne fonctionne que pour Java 7 ou une version ultérieure. Il y a encore beaucoup de personnes qui travaillent avec Java 5 (ou pire), qui ne peuvent pas bénéficier de l'essayer-avec-des ressources de la fonctionnalité.
- Je suppose que même ceux qui ne peuvent pas écrire de Java 7 peut lire Java 7 et de savoir comment fermer un fichier lorsque vous avez terminé avec elle. J' ne pas assume que les gens savent lire Java 8, cependant, et l'ajustement du rétro stream/les lambdas. 😉
- qu'entendez-vous par "ne fonctionne pas" et quel est le problème que vous avez toujours?
- java.lang.OutOfMemoryError: Java heap space
- si vous avez des lignes très longues et très petite quantité de mémoire que vous pouvez avoir besoin pour traiter une seule ligne à la fois, ou une partie d'une ligne à la fois. Si vous exécutez l'exemple ci-dessus ne vous obtenez OOME, ou est-il lorsque vous traitez ces lignes? c'est à dire la OOME qui se produisent dans votre code, dans cette bibliothèque?
- Il y a donc beaucoup de lignes, le fichier est d'environ 1 Gig, mais chaque ligne est courte. Je reçois OOME quand j'ai essayé de lire le fichier d'aide de ce code et juste l'impression de chacun d'eux.
- dans ce cas, je voudrais utiliser le BufferedReader boucle.
- comme au-dessous de la réponse?
- Je pense que ma réponse est plus claire, car il utilise essayer-avec-ressource. Voir la deuxième ligne de ma réponse.
- Toujours le même problème, même quand je l'augmentation de la Java de la taille du segment!
- Ce n'est qu'en tenant une ligne à la fois, donc si vous avez un OOME vous avez une très longue ligne parce que c'est tout ce qui est conservé.
- Lorsque je l'utilise pour les fichiers plus courts (300 Mo), c'est Ok, mais pour 1,5 G de fichier, j'obtiens OOME erreur.
- pour que cela se produise avec BufferedReader vous devez être rétention de données quelque part que seule la longueur de la ligne de questions autrement.
- Soyez prudent en utilisant le Java 8 Fichiers.lignes() la méthode. Il gère l'encodage différemment. Le BufferedReader est indulgent et se chargera de non-utf8 caractères, sans chichi, mais le Fichier.lignes() lève une exception si elle rencontre un non-utf8 char. Vous devez spécifier l'encodage que vous attendez avec Fichiers.lignes() si elle n'est pas la valeur par défaut utf-8.
InformationsquelleAutor Peter Lawrey
137

Oeil à ce blog:
- Java Lire le Fichier ligne par Ligne - Tutoriel Java
La taille de la mémoire tampon peut être spécifié, ou
la taille par défaut peut être utilisé. L'
par défaut est assez grand pour la plupart des
fins.
```
//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
fstream.close();
```
- Mon fichier est de 1,5 Concert et il n'est pas possible de lire le fichier à l'aide de votre réponse!
- Il est bien sûr possible. Ce code permet de lire n'importe quel fichier texte.
- Downvoted de la mauvaise qualité du lien. Il est complètement inutile DataInputStream, et le mauvais flux est fermé. Rien de mal avec le Java Tutoriel, et pas besoin de citer arbitraire Internet tiers des ordures comme ceci.
InformationsquelleAutor Naveed
84

Une fois java-8 est de sortir (Mars 2014), vous serez en mesure d'utiliser les flux:
```
try (Stream<String> lines = Files.lines(Paths.get(filename), Charset.defaultCharset())) {
  lines.forEachOrdered(line -> process(line));
}
```
Impression de toutes les lignes dans le fichier:
```
try (Stream<String> lines = Files.lines(file, Charset.defaultCharset())) {
  lines.forEachOrdered(System.out::println);
}
```
- Utilisation StandardCharsets.UTF_8, utilisez Stream<String> pour la concision, et éviter d'utiliser forEach() et surtout forEachOrdered() moins qu'il y a une raison.
- Pourquoi éviter forEach()? Est-il mauvais?
- Si je nous forEach au lieu de forEachOrdered, les lignes peuvent être imprimées de l'ordre, n'est-ce pas?
- Regardez: stackoverflow.com/questions/16635398/... Il n'est pas mauvais si vous passez une courte référence à une fonction comme forEach(this::process), mais il devient laid si vous écrivez des blocs de code que les lambdas à l'intérieur de forEach().
- Vous avez raison, vous avez besoin forEachOrdered afin de les exécuter dans l'ordre. Sachez que vous ne serez pas capable de paralléliser le flux dans ce cas, même si j'ai trouvé que la parallélisation ne s'allume pas sauf si le fichier a des milliers de lignes.
InformationsquelleAutor msayag

Voici un exemple avec plein d'erreur de manipulation et de soutien charset spécification pour le pré-Java 7. Avec Java 7, vous pouvez utiliser essayez-avec-les ressources de la syntaxe, ce qui rend le code plus propre.

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

Ici est la version Groovy, avec plein d'erreur de manipulation:

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

Que fait un ByteArrayInputStream alimenté par un littéral de chaîne ont à voir avec la lecture d'un gros fichier texte?
absolument inutile ferme. Il n'y a aucune raison de fermer tous les cours d'eau. Si vous fermez un de ces cours d'eau, vous automatiquement, fermez tous les autres cours d'eau...

InformationsquelleAutor DarkStar

21

Dans Java 8, vous pouvez faire:
```
try (Stream<String> lines = Files.lines (file, StandardCharsets.UTF_8))
{
    for (String line : (Iterable<String>) lines::iterator)
    {
        ;
    }
}
```
Quelques remarques: Le flux renvoyé par Files.lines (contrairement à la plupart des cours d'eau) doit être fermé. Pour les raisons mentionné ici - je éviter d'utiliser forEach(). L'étrange code (Iterable<String>) lines::iterator jette un Flux vers un objet iterable.
- En n'appliquant pas les Iterable ce code est définitivement vilain bien que utile. Il a besoin d'un plâtre (c'est à dire (Iterable<String>)) au travail.
- Comment puis-je me passer de la première ligne avec cette méthode?
- ligne : (Itérable<String>) lignes.sauter(1)::iterator)
- Si vous ne prévoyez pas d'utiliser effectivement Stream caractéristiques, à l'aide de Files.newBufferedReader au lieu de Files.lines et à plusieurs reprises d'appeler readLine() jusqu'à null au lieu d'utiliser des constructions comme les (Iterable<String>) lines::iterator semble être beaucoup plus simple...
- Pourquoi utilisez-vous : dans les lignes::iterator? La seule utilisation que je sais :: est de package nom de la méthode en fonction lambda. Dans la boucle for paramètre après : doit être variable tandis que vous obtenez certains lambda méthode à l'aide de ::
- le code crée en effet un lambda. Le lambda est ensuite coulé dans un Iterable (ceci est possible car Iterable est une interface fonctionnelle). Pour la boucle, puis effectue une itération sur ce nouvel objet. Tout cela est nécessaire parce que l'interface Stream n'hérite pas de Iterable en dépit de la satisfaction de son contrat.
InformationsquelleAutor Aleksandr Dubinsky
19

Ce que vous pouvez faire est de scanner l'ensemble du texte à l'aide du Scanner et de passer par le texte ligne par ligne.
Bien sûr, vous devez importer les suivants:
```
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 fondamentalement scanne l'intégralité du texte. La boucle while est utilisée pour parcourir l'intégralité du texte.

La .hasNextLine() fonction est une valeur booléenne qui renvoie true si il y a encore plus de lignes dans le texte. Le .nextLine() fonction vous donne une ligne entière comme une Chaîne de caractères que vous pouvez utiliser comme vous le souhaitez. Essayez System.out.println(line) pour imprimer le texte.

Note De Côté: .txt est le type de fichier texte.
- Ne pas la déclaration de la méthode au lieu de ceci: public static void readText throws FileNotFoundException(){ Comme: public static void readText() throws FileNotFoundException{
- Ce qui est considérablement plus lent que BufferedReader.readLine(), et il a demandé pour la meilleure performance de la méthode.
InformationsquelleAutor iskandarchacra
17

FileReader ne vous laisseront pas de spécifier l'encodage, l'utilisation InputStreamReaderà la place si vous avez besoin de le préciser:
```
try {
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "Cp1252"));         

    String line;
    while ((line = br.readLine()) != null) {
        //process the line.
    }
    br.close();

} catch (IOException e) {
    e.printStackTrace();
}
```
Si vous avez importé ce fichier à partir de Windows, il peut avoir l'encodage ANSI (Cp1252), vous devez spécifier l'encodage.
- Bon point. Une autre façon est d'utiliser des Files.newBufferedReader
InformationsquelleAutor live-love
16

Dans 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);
}
```
- être conscient! l'aide en ligne.split de cette façon ne sera PAS analyser correctement si un champ contient une virgule et il est entouré par des guillemets. Cette séparation de l'ignorer cela et juste séparer le terrain en morceaux à l'aide de l'intérieur par des virgules. HTH, Marcelo.
- CSV: Valeurs Séparées par des Virgules fichier, donc vous ne devriez pas utiliser la virgule dans un fichier csv champ, sauf si vous voulez ajouter un autre champ. Ainsi, l'utilisation de split pour virgule jeton en java lors de l'analyse d'un fichier CSV est parfaitement bien et droit
- Diego, ce n'est pas correct. La seule CSV standard (RFC 4180) spécifiquement dit "les Champs contenant des sauts de ligne (CRLF), les guillemets doubles, et les virgules doivent être entre guillemets doubles."
- Utilisation StandardCharsets.UTF_8 pour éviter l'objet d'une exception en Charset.forName("UTF-8")
- Merci "Diego Duarte" pour votre commentaire; je dois dire que je suis d'accord avec ce "serg.nechaev" réponses. Je vois des virgules incorporées dans des fichiers csv 'tout le temps'. Les gens s'attendre à ce que ce ne sera acceptée. avec tout le respect dû. également un grand merci à "serg.nechaev". À mon humble avis, vous avez raison. Cheerse Tout Le Monde.
InformationsquelleAutor Diego Duarte

J'ai documenté et testé 10 façons différentes de lire un fichier en Java, puis a couru l'un contre l'autre en les faisant lire dans les fichiers de test à partir de 1 KO à 1 go. Voici la manière la plus rapide de fichiers 3 les méthodes de lecture pour la lecture d'un 1 go de fichier de test.

Noter que lors de l'exécution des tests de performance, je n'ai pas l'affichage de la console parce que ce serait vraiment ralentir le test. Je voulais juste tester la lecture brute de vitesse.

1) de java.nio.fichier.Les fichiers.readAllBytes()

Testé dans Java 7, 8, 9. Ce fut dans l'ensemble, la méthode la plus rapide. La lecture d'un fichier de 1 go a été constamment un peu moins de 1 seconde.

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) de java.nio.fichier.Les fichiers.lignes()

Cela a été testé avec succès dans Java 8 et 9, mais il ne fonctionnera pas dans Java 7 en raison de l'absence de soutien pour les expressions lambda. Il a fallu environ 3,5 secondes pour lire dans un fichier de 1 go qui a mis en deuxième place en ce qui concerne la lecture des fichiers plus volumineux.

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

Testé pour fonctionner dans Java 7, 8, 9. Cela a pris environ 4,5 secondes pour lire dans un 1 go de fichier de 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);
      }
    }
  }

Vous pouvez trouver les classements complets pour tous les 10 fichier méthodes de lecture ici.

Votre guide est incroyable 🙂

InformationsquelleAutor gomisha

Pour la Lecture du 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();
        }
        }
    }

InformationsquelleAutor Ankit Sood

9

Vous pouvez utiliser le Scanner de classe
```
Scanner sc=new Scanner(file);
sc.nextLine();
```
- Ce sera de la bombe horriblement sur un gros fichier. Gros fichier a été une partie de l'OP de la question.
- horriblement " n'est pas un terme que je reconnaître dans CS. Que voulez-vous dire exactement?
- Enlisent, les exécuter très lentement, le plus probable crash. Je devrais probablement éviter les expressions idiomatiques sur ce site 😉
- Pourquoi serait-il le faire?
- À l'aide de Scanner est bien, mais cette réponse n'a pas d'inclure le code pour l'utiliser correctement.
- Ce code ne sera ni la "bombe horriblement", ni les "boguer" ni "exécuter très lentement", ni les "plus probable crash". Comme une question de fait, comme l'écrit il seulement lu une ligne, presque instaneously. Vous pouvez lire mégaoctets par seconde de cette façon, bien que BufferedReader.readLine() est certainement plusieurs fois plus rapide. Si vous pensez le contraire, veuillez fournir vos raisons.
InformationsquelleAutor Abhilash
9

Dans Java 8, il existe une alternative à l'utilisation de Fichiers.lignes(). 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 flux les lignes via le BufferedReaders lines() méthode.

Par exemple:
```
try (BufferedReader reader = new BufferedReader(...)) {
  reader.lines().foreach(line -> processLine(line));
}
```
appellera processLine() pour chaque ligne de saisie lu par le BufferedReader.

InformationsquelleAutor Rüdiger Herrmann
7

Vous devez utiliser le readLine() méthode dans class BufferedReader.
Créer un nouvel objet de cette classe et de faire fonctionner cette méthode sur lui et l'enregistrer sur une chaîne.

BufferReader Javadoc
- Semble que le lien pour BufferReaderAPI est cassé
InformationsquelleAutor Master C
6

Java-9 :
```
try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
        stream.forEach(System.out::println);
}
```
- Le code de avoir un but? Par exemple, est-il plus rapide?
- Je pense que vous avez à System.getProperty("os.name").equals("Linux")
- Ne pas comparer des chaînes de caractères avec == !
- Vous pensez que c'est pourquoi? Vous avez tort.
- C'est la forme canonique de Java 8 exemple, comme déjà signalé par d'autres. Pourquoi avez-vous prétendre que c'est “Java-9”?
- les fichiers mappés en mémoire qu'il a oublié de mentionner, peut-être?
InformationsquelleAutor Abdennour TOUMI

Le moyen de parvenir,

Par exemple:

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

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,
Comment lire un gros fichier texte ligne par ligne à l'aide de Java?

Pourquoi est-il plus clair? Et de ne pas publier de photos de texte ici. Afficher le texte.
Vous avez posté une image. C'est une image du texte. Vous pourriez avoir coupé et collé le texte directement dans cette page. Personne n'a rien dit au sujet de l'affichage des programmes. De publier des photos de texte est un gaspillage de votre temps, ce qui je ne se soucient pas, et oyur de la bande passante, ce qui je ne.

InformationsquelleAutor Rajamohan S

BufferedReader br;
FileInputStream fin;
try {
    fin = new FileInputStream(fileName);
    br = new BufferedReader(new InputStreamReader(fin));

    /*Path pathToFile = Paths.get(fileName);
    br = Files.newBufferedReader(pathToFile,StandardCharsets.US_ASCII);*/

    String line = br.readLine();
    while (line != null) {
        String[] attributes = line.split(",");
        Movie movie = createMovie(attributes);
        movies.add(movie);
        line = br.readLine();
    }
    fin.close();
    br.close();
} catch (FileNotFoundException e) {
    System.out.println("Your Message");
} catch (IOException e) {
    System.out.println("Your Message");
}

Cela fonctionne pour moi. Espérons qu'Il saura vous aider aussi.

InformationsquelleAutor Dipendra Ghatal

J'ai l'habitude de faire 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) {
        }
    }
}

InformationsquelleAutor Binkan Salaryman

1

Vous pouvez utiliser les flux de le faire plus précisément:
```
Files.lines(Paths.get("input.txt")).forEach(s -> stringBuffer.append(s);
```
- Quoi de mal dans cette réponse?
- Quoi de mal là-dedans??? Pourquoi personne n'est à fournir des commentaires??
- Je suis d'accord qu'il est réellement bien. Aguess, les gens n'aiment pas cela à cause de l'étrange StringBuffer choix (StringBuilder est généralement préféré, même si c'est peut-être juste un mauvais nom de variable). Aussi parce qu'il est déjà mentionné ci-dessus.
InformationsquelleAutor spidy
0

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();
}
```
- FileUtils.readLines(file) est une méthode dépréciée. En outre, la méthode appelle IOUtils.readLines, qui utilise un BufferedReader et ArrayList. Ce n'est pas une, ligne par ligne, de la méthode, et certainement pas l'un qui serait pratique pour la lecture de plusieurs GO.
InformationsquelleAutor To Kra

Vous pouvez utiliser ce code:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadTextFile {

    public static void main(String[] args) throws IOException {

        try {

            File f = new File("src/com/data.txt");

            BufferedReader b = new BufferedReader(new FileReader(f));

            String readLine = "";

            System.out.println("Reading file using Buffered Reader");

            while ((readLine = b.readLine()) != null) {
                System.out.println(readLine);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

InformationsquelleAutor Usman Yaqoob

en utilisant org.apache.commons.io package a donné plus de performances, en particulier dans l'ancien code qui utilise Java 6 et ci-dessous.

Java7 a mieux API avec le moins d'exceptions
la manipulation et la plus utile des méthodes

LineIterator lineIterator =null;
    try{
    lineIterator = FileUtils.lineIterator(new File("/home/username/m.log"), "windows-1256");//second parameter is optionanl
    while (lineIterator.hasNext()){
      String currentLine = lineIterator.next();   
     //some operation
    } 
    }finally {  
     LineIterator.closeQuietly(lineIterator);
    }

maven

<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

InformationsquelleAutor mohsen.nour

Vous devez vous connecter pour publier un commentaire.

Java-9 :