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?
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?
Réponses:
Un modèle courant consiste à 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 supposez qu'il n'y a pas de codage de caractères. par exemple ASCII-7 mais cela ne fera pas beaucoup de différence. Il est fort probable que ce que vous faites avec les données prenne beaucoup plus de temps.
EDIT: un modèle moins courant à utiliser qui évite l'ampleur des line
fuites.
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: Dans Java 8, vous pouvez faire
try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
stream.forEach(System.out::println);
}
REMARQUE: Vous devez placer le Stream dans un bloc try-with-resource pour vous assurer que la méthode #close est appelée dessus, sinon le descripteur de fichier sous-jacent n'est jamais fermé jusqu'à ce que GC le fasse beaucoup plus tard.
for(String line = br.readLine(); line != null; line = br.readLine())
Btw, en Java 8 vous pouvez faire try( Stream<String> lines = Files.lines(...) ){ for( String line : (Iterable<String>) lines::iterator ) { ... } }
ce qui est difficile à ne pas haïr.
Regardez ce blog:
La taille du 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 applications.
// 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();
DataInputStream
, et le mauvais flux est fermé. Rien de mal avec le tutoriel Java, et pas besoin de citer des déchets Internet tiers arbitraires comme celui-ci.
Une fois Java 8 sorti (mars 2014), vous pourrez utiliser des flux:
try (Stream<String> lines = Files.lines(Paths.get(filename), Charset.defaultCharset())) {
lines.forEachOrdered(line -> process(line));
}
Impression de toutes les lignes du fichier:
try (Stream<String> lines = Files.lines(file, Charset.defaultCharset())) {
lines.forEachOrdered(System.out::println);
}
StandardCharsets.UTF_8
, utilisez Stream<String>
pour la concision, et évitez d'utiliser forEach()
et surtout à forEachOrdered()
moins qu'il y ait une raison.
forEach(this::process)
, mais cela devient moche si vous écrivez des blocs de code en tant que lambdas à l'intérieur forEach()
.
forEachOrdered
pour exécuter dans l'ordre. Sachez que vous ne pourrez pas paralléliser le flux dans ce cas, même si j'ai constaté que la parallélisation ne s'active que si le fichier contient des milliers de lignes.
Voici un exemple avec gestion complète des erreurs et prise en charge de la spécification de jeu de caractères pour pré-Java 7. Avec Java 7, vous pouvez utiliser la syntaxe try-with-resources, 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 une gestion complète des erreurs:
File f = new File("textfile.txt");
f.withReader("UTF-8") { br ->
br.eachLine { line ->
println line;
}
}
ByteArrayInputStream
littéral alimenté par une chaîne a à voir avec la lecture d'un gros fichier texte?
En Java 8, vous pourriez faire:
try (Stream<String> lines = Files.lines (file, StandardCharsets.UTF_8))
{
for (String line : (Iterable<String>) lines::iterator)
{
;
}
}
Quelques notes: Le flux renvoyé par Files.lines
(contrairement à la plupart des flux) doit être fermé. Pour les raisons mentionnées ici, j'évite d'utiliser forEach()
. L'étrange code (Iterable<String>) lines::iterator
transforme un Stream en Iterable.
Iterable
ce code est définitivement moche bien qu'utile. Il a besoin d'un casting (ie (Iterable<String>)
) pour fonctionner.
for(String line : (Iterable<String>) lines.skip(1)::iterator)
Stream
fonctionnalités, utiliser Files.newBufferedReader
au lieu d' Files.lines
appeler et répéter readLine()
jusqu'à ce que, null
au lieu d'utiliser des constructions comme (Iterable<String>) lines::iterator
semble être beaucoup plus simple…
Ce que vous pouvez faire est de numériser le texte entier à l'aide du scanner et de parcourir le texte ligne par ligne. Bien sûr, vous devez importer les éléments 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
}
}
Le scanner scanne essentiellement tout le texte. La boucle while est utilisée pour parcourir tout le texte.
La .hasNextLine()
fonction est un booléen qui renvoie true s'il y a encore plus de lignes dans le texte. La .nextLine()
fonction vous donne une ligne entière sous forme de chaîne que vous pouvez ensuite utiliser comme vous le souhaitez. Essayez System.out.println(line)
d'imprimer le texte.
Note latérale: .txt est le texte du type de fichier.
BufferedReader.readLine()
, et il a demandé la méthode la plus performante.
FileReader ne vous permet pas de spécifier l'encodage, utilisez-le à la InputStreamReader
place si vous devez le spécifier:
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 un encodage ANSI (Cp1252), vous devez donc spécifier l'encodage.
J'ai documenté et testé 10 façons différentes de lire un fichier en Java , puis je les ai exécutées les unes contre les autres en les faisant lire des fichiers de test de 1 Ko à 1 Go. Voici les 3 méthodes de lecture de fichiers les plus rapides pour lire un fichier de test de 1 Go.
Notez que lors de l'exécution des tests de performances, je n'ai rien sorti sur la console car cela ralentirait vraiment le test. Je voulais juste tester la vitesse de lecture brute.
1) java.nio.file.Files.readAllBytes ()
Testé en Java 7, 8, 9. C'était globalement la méthode la plus rapide. La lecture d'un fichier de 1 Go était systématiquement un peu moins d'une 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) java.nio.file.Files.lines ()
Cela a été testé avec succès en Java 8 et 9, mais cela ne fonctionnera pas en Java 7 en raison du manque de prise en charge des expressions lambda. Il a fallu environ 3,5 secondes pour lire un fichier de 1 Go, ce qui l'a placé en deuxième position pour la lecture de 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 en Java 7, 8, 9. Cela a pris environ 4,5 secondes pour lire dans un fichier de test de 1 Go.
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 le classement complet des 10 méthodes de lecture de fichiers ici .
System.out.print/println()
ici; vous supposez également que le fichier tiendra dans la mémoire dans vos deux premiers cas.
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);
}
StandardCharsets.UTF_8
pour éviter l'exception cochée dansCharset.forName("UTF-8")
Dans Java 8, il existe également une alternative à l'utilisation 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 diffuser les lignes via la méthode BufferedReader
s lines()
.
Par exemple:
try (BufferedReader reader = new BufferedReader(...)) {
reader.lines().forEach(line -> processLine(line));
}
appellera processLine()
pour chaque ligne d'entrée lue par le BufferedReader
.
Pour lire un 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();
}
}
}
Vous pouvez utiliser la classe Scanner
Scanner sc=new Scanner(file);
sc.nextLine();
Scanner
est très bien, mais cette réponse n'inclut pas le code complet pour l'utiliser correctement.
BufferedReader.readLine()
soit certainement plusieurs fois plus rapide. Si vous pensez le contraire, veuillez fournir vos raisons.
Vous devez utiliser la readLine()
méthode dans class BufferedReader
. Créez un nouvel objet à partir de cette classe et opérez cette méthode sur lui et enregistrez-le dans une chaîne.
La manière claire 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();
}
}
try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
stream.forEach(System.out::println);
}
System.getProperty("os.name").equals("Linux")
==
!
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");
}
Ça marche pour moi. J'espère que cela vous aidera aussi.
Vous pouvez utiliser des flux pour le faire plus précisément:
Files.lines(Paths.get("input.txt")).forEach(s -> stringBuffer.append(s);
Je fais habituellement 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 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();
}
}
}
En utilisant le package org.apache.commons.io , il a donné plus de performances, en particulier dans le code hérité qui utilise Java 6 et inférieur.
Java 7 a une meilleure API avec moins de gestion des exceptions et des méthodes plus utiles:
LineIterator lineIterator = null;
try {
lineIterator = FileUtils.lineIterator(new File("/home/username/m.log"), "windows-1256"); // The second parameter is optionnal
while (lineIterator.hasNext()) {
String currentLine = lineIterator.next();
// Some operation
}
}
finally {
LineIterator.closeQuietly(lineIterator);
}
<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.6</version>
</dependency>
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 obsolète. En outre, la méthode appelle IOUtils.readLines
, qui utilise un BufferedReader et ArrayList. Ce n'est pas une méthode ligne par ligne, et certainement pas une méthode qui serait pratique pour lire plusieurs Go.