ASCII ist eine TEXT-Datei, die Sie Readerszum Lesen verwenden würden. Java unterstützt auch das Lesen aus einer Binärdatei mit InputStreams. Wenn die gelesenen Dateien sehr groß sind, sollten Sie a BufferedReaderüber a verwenden FileReader, um die Leseleistung zu verbessern.
Lesen Sie diesen Artikel über die Verwendung von aReader
Ich würde Ihnen auch empfehlen, dieses wunderbare (und dennoch kostenlose) Buch namens Thinking In Java herunterzuladen und zu lesen
Die Auswahl eines Readers hängt wirklich davon ab, wofür Sie den Inhalt der Datei benötigen. Wenn die Datei klein ist (ish) und Sie alles benötigen, ist es schneller (von uns bewertet: 1.8-2x), einfach einen FileReader zu verwenden und alles zu lesen (oder zumindest ausreichend große Blöcke). Wenn Sie es Zeile für Zeile verarbeiten, wählen Sie den BufferedReader.
Vlad
3
Wird die Zeilenreihenfolge bei Verwendung von "Files.lines (..). ForEach (...)" beibehalten? Mein Verständnis ist, dass die Reihenfolge nach dieser Operation willkürlich sein wird.
Daniil Shevelev
39
Files.lines(…).forEach(…)behält die Reihenfolge der Zeilen nicht bei, wird jedoch parallel ausgeführt, @Dash. Wenn die Bestellung wichtig ist, können Sie verwenden Files.lines(…).forEachOrdered(…), wodurch die Bestellung erhalten bleiben soll (wurde jedoch nicht überprüft).
Palec
2
@Palec das ist interessant, aber können Sie aus den Dokumenten zitieren, in denen steht, dass Files.lines(...).forEach(...)parallel ausgeführt wird? Ich dachte, dies sei nur dann der Fall, wenn Sie den Stream explizit parallel verwenden Files.lines(...).parallel().forEach(...).
Klitos Kyriacou
3
Meine ursprüngliche Formulierung ist nicht kugelsicher, @KlitosKyriacou. Der Punkt ist, dass forEachkeine Bestellung garantiert wird und der Grund eine einfache Parallelisierung ist. Wenn die Ordnung erhalten bleiben soll, verwenden Sie forEachOrdered.
Palec
687
Meine Lieblingsmethode zum Lesen einer kleinen Datei ist die Verwendung eines BufferedReader und eines StringBuilder. Es ist sehr einfach und auf den Punkt gebracht (obwohl nicht besonders effektiv, aber für die meisten Fälle gut genug):
BufferedReader br =newBufferedReader(newFileReader("file.txt"));try{StringBuilder sb =newStringBuilder();String line = br.readLine();while(line !=null){
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();}String everything = sb.toString();}finally{
br.close();}
Einige haben darauf hingewiesen, dass Sie nach Java 7 die Funktionen zum Ausprobieren von Ressourcen (dh zum automatischen Schließen) verwenden sollten:
try(BufferedReader br =newBufferedReader(newFileReader("file.txt"))){StringBuilder sb =newStringBuilder();String line = br.readLine();while(line !=null){
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();}String everything = sb.toString();}
Wenn ich solche Zeichenfolgen lese, möchte ich normalerweise sowieso eine Zeichenfolgenbehandlung pro Zeile durchführen, also gehe ich zu dieser Implementierung.
Wenn ich jedoch nur eine Datei in einen String einlesen möchte, verwende ich immer Apache Commons IO mit der Klasse IOUtils.toString (). Die Quelle können Sie hier einsehen:
try(FileInputStream inputStream =newFileInputStream("foo.txt")){String everything =IOUtils.toString(inputStream);// do something with everything string}
Ich habe eine kleine Anpassung vorgenommen, um das Hinzufügen einer neuen Zeile (\ n) zu beenden, wenn die letzte Zeile erreicht ist. code while (Zeile! = null) {sb.append (Zeile); line = br.readLine (); // Neue Zeile nur hinzufügen, wenn curline NICHT die letzte Zeile ist .. if (line! = Null) {sb.append ("\ n"); }}code
Ramon Fincken
2
Ähnlich wie bei Apache Common IO ist IOUtils # toString () sun.misc.IOUtils # readFully (), das in den Sun / Oracle-JREs enthalten ist.
gb96
3
Rufen Sie für die Leistung immer sb.append ('\ n') vor sb.append ("\ n") auf, da ein
Zeichen
2
FileReader kann FileNotFoundException auslösen und BufferedRead kann IOException auslösen, sodass Sie sie abfangen müssen.
Am einfachsten ist es, die ScannerKlasse in Java und das FileReader-Objekt zu verwenden. Einfaches Beispiel:
Scanner in =newScanner(newFileReader("filename.txt"));
Scanner Es gibt verschiedene Methoden zum Einlesen von Zeichenfolgen, Zahlen usw. Weitere Informationen hierzu finden Sie auf der Java-Dokumentationsseite.
oder verwenden Sie "try-with-resources" try (FileReader reader = neuer FileReader (Datei))
Hernán Eche
3
Ich habe die Datei file.length () bemerkt. Wie gut funktioniert das mit utf-16-Dateien?
Wayne
5
Diese Technik setzt voraus, dass read () den Puffer füllt; dass die Anzahl der Zeichen der Anzahl der Bytes entspricht; dass die Anzahl der Bytes in den Speicher passt; und dass die Anzahl der Bytes in eine ganze Zahl passt. -1
Marquis von Lorne
1
@ HermesTrismegistus Ich habe vier Gründe angegeben, warum es falsch ist. StefanReich stimmt mir zu Recht zu.
Marquis von Lorne
34
Ich musste die verschiedenen Wege vergleichen. Ich werde meine Ergebnisse kommentieren, aber kurz gesagt, der schnellste Weg ist, einen einfachen alten BufferedInputStream über einen FileInputStream zu verwenden. Wenn viele Dateien gelesen werden müssen, reduzieren drei Threads die Gesamtausführungszeit auf ungefähr die Hälfte. Wenn Sie jedoch mehr Threads hinzufügen, wird die Leistung schrittweise beeinträchtigt, bis die Fertigstellung mit zwanzig Threads dreimal länger dauert als mit nur einem Thread.
Die Annahme ist, dass Sie eine Datei lesen und mit ihrem Inhalt etwas Sinnvolles tun müssen. In den Beispielen werden hier Zeilen aus einem Protokoll gelesen und diejenigen gezählt, die Werte enthalten, die einen bestimmten Schwellenwert überschreiten. Ich gehe also davon aus, dass der Einzeiler Java 8Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) keine Option ist.
Ich habe auf Java 1.8, Windows 7 und sowohl SSD- als auch HDD-Laufwerken getestet.
Ich habe sechs verschiedene Implementierungen geschrieben:
rawParse : Verwenden Sie BufferedInputStream über einen FileInputStream und schneiden Sie dann die byteweisen Zeilen aus. Dies übertraf jeden anderen Single-Thread-Ansatz, kann jedoch für Nicht-ASCII-Dateien sehr unpraktisch sein.
lineReaderParse : Verwenden Sie einen BufferedReader über einem FileReader, lesen Sie Zeile für Zeile, teilen Sie Zeilen, indem Sie String.split () aufrufen. Dies ist ungefähr 20% langsamer als rawParse.
lineReaderParseParallel : Dies ist dasselbe wie lineReaderParse, verwendet jedoch mehrere Threads. Dies ist in allen Fällen die schnellste Option insgesamt.
nioFilesParse : Verwenden Sie java.nio.files.Files.lines ()
nioAsyncParse : Verwenden Sie einen AsynchronousFileChannel mit einem Completion-Handler und einem Thread-Pool.
nioMemoryMappedParse : Verwenden Sie eine Speicherzuordnungsdatei. Dies ist wirklich eine schlechte Idee, da die Ausführungszeiten mindestens dreimal länger sind als bei jeder anderen Implementierung.
Dies sind die durchschnittlichen Zeiten für das Lesen von 204 Dateien mit jeweils 4 MB auf einem Quad-Core i7- und SSD-Laufwerk. Die Dateien werden im laufenden Betrieb generiert, um ein Zwischenspeichern der Festplatte zu vermeiden.
Ich fand einen kleineren Unterschied als erwartet zwischen der Ausführung auf einer SSD oder einem Festplattenlaufwerk, da die SSD ungefähr 15% schneller ist. Dies kann daran liegen, dass die Dateien auf einer nicht fragmentierten Festplatte generiert und nacheinander gelesen werden. Daher kann das sich drehende Laufwerk fast wie eine SSD funktionieren.
Ich war von der geringen Leistung der nioAsyncParse-Implementierung überrascht. Entweder habe ich etwas falsch implementiert oder die Multi-Thread-Implementierung mit NIO und einem Completion-Handler führt die gleiche (oder sogar schlechtere) Leistung aus wie eine Single-Thread-Implementierung mit der java.io-API. Darüber hinaus ist die asynchrone Analyse mit einem CompletionHandler in Codezeilen viel länger und schwierig korrekt zu implementieren als eine direkte Implementierung in alten Streams.
Jetzt die sechs Implementierungen, gefolgt von einer Klasse, die sie alle enthält, sowie einer parametrierbaren main () -Methode, mit der mit der Anzahl der Dateien, der Dateigröße und dem Grad der Parallelität gespielt werden kann. Beachten Sie, dass die Größe der Dateien plus plus 20% variiert. Dies dient dazu, Auswirkungen zu vermeiden, da alle Dateien genau dieselbe Größe haben.
rawParse
publicvoid rawParse(finalString targetDir,finalint numberOfFiles)throwsIOException,ParseException{
overrunCount =0;finalint dl =(int)';';StringBuffer lineBuffer =newStringBuffer(1024);for(int f=0; f<numberOfFiles; f++){File fl =newFile(targetDir+filenamePreffix+String.valueOf(f)+".txt");FileInputStream fin =newFileInputStream(fl);BufferedInputStream bin =newBufferedInputStream(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();}}publicfinalvoid doSomethingWithRawLine(String line)throwsParseException{// What to do for each lineint fieldNumber =0;finalint len = line.length();StringBuffer fieldBuffer =newStringBuffer(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){case0:Date dt = fmt.parse(fieldValue);
fieldNumber++;break;case1:double d =Double.parseDouble(fieldValue);
fieldNumber++;break;case2:int t =Integer.parseInt(fieldValue);
fieldNumber++;break;case3:if(fieldValue.equals("overrun"))
overrunCount++;break;}}
fieldBuffer.setLength(0);}else{
fieldBuffer.append(c);}}}
lineReaderParse
publicvoid lineReaderParse(finalString targetDir,finalint numberOfFiles)throwsIOException,ParseException{String line;for(int f=0; f<numberOfFiles; f++){File fl =newFile(targetDir+filenamePreffix+String.valueOf(f)+".txt");FileReader frd =newFileReader(fl);BufferedReader brd =newBufferedReader(frd);while((line=brd.readLine())!=null)
doSomethingWithLine(line);
brd.close();
frd.close();}}publicfinalvoid doSomethingWithLine(String line)throwsParseException{// Example of what to do for each lineString[] 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++;}
publicvoid nioFilesParse(finalString targetDir,finalint numberOfFiles)throwsIOException,ParseException{for(int f=0; f<numberOfFiles; f++){Path ph =Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");Consumer<String> action =newLineConsumer();Stream<String> lines =Files.lines(ph);
lines.forEach(action);
lines.close();}}classLineConsumerimplementsConsumer<String>{@Overridepublicvoid accept(String line){// What to do for each lineString[] 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
publicvoid nioAsyncParse(finalString targetDir,finalint numberOfFiles,finalint numberOfThreads,finalint bufferSize)throwsIOException,ParseException,InterruptedException{ScheduledThreadPoolExecutor pool =newScheduledThreadPoolExecutor(numberOfThreads);ConcurrentLinkedQueue<ByteBuffer> byteBuffers =newConcurrentLinkedQueue<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 =newBufferConsumer(byteBuffers, fileName, bufferSize);
channel.read(consumer.buffer(),0l, channel, consumer);}
consumerThreads.acquire(numberOfThreads);}classBufferConsumerimplementsCompletionHandler<Integer,AsynchronousFileChannel>{privateConcurrentLinkedQueue<ByteBuffer> buffers;privateByteBuffer bytes;privateString file;privateStringBuffer chars;privateint limit;privatelong position;privateDateFormat frmt =newSimpleDateFormat("yyyy-MM-dd HH:mm:ss");publicBufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers,String fileName,int bufferSize){
buffers = byteBuffers;
bytes = buffers.poll();if(bytes==null)
bytes =ByteBuffer.allocate(bufferSize);
file = fileName;
chars =newStringBuffer(bufferSize);
frmt =newSimpleDateFormat("yyyy-MM-dd HH:mm:ss");
limit = bufferSize;
position =0l;}publicByteBuffer buffer(){return bytes;}@Overridepublicsynchronizedvoid completed(Integer result,AsynchronousFileChannel channel){if(result!=-1){
bytes.flip();finalint 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);}}@Overridepublicvoid failed(Throwable e,AsynchronousFileChannel channel){}};
Oder Sie verwenden einfach die integrierte Methode, um alle Zeilen
abzurufen
Link auf Apache Commons scheint tot zu sein.
Kebs
17
Was möchten Sie mit dem Text machen? Ist die Datei klein genug, um in den Speicher zu passen? Ich würde versuchen, den einfachsten Weg zu finden, um die Datei für Ihre Bedürfnisse zu handhaben. Die FileUtils-Bibliothek ist dafür sehr gut geeignet.
@ PeterLawrey bedeutet wahrscheinlich org.apache.commons.io.FileUtils. Der Google-Link kann den Inhalt im Laufe der Zeit ändern, da sich die am weitesten verbreitete Bedeutung ändert. Dies entspricht jedoch seiner Abfrage und sieht korrekt aus.
Palec
2
Leider gibt es heutzutage keine readLines(String)und readLines(File)wird zugunsten von veraltet readLines(File, Charset). Die Codierung kann auch als Zeichenfolge angegeben werden.
Ich habe 15 Möglichkeiten zum Lesen einer Datei in Java dokumentiert und sie dann mit verschiedenen Dateigrößen auf Geschwindigkeit getestet - von 1 KB bis 1 GB. Hier sind die drei wichtigsten Möglichkeiten, dies zu tun:
Im Folgenden finden Sie einen Einzeiler, wie Sie dies auf Java 8-Weise tun können. Angenommen, die text.txtDatei befindet sich im Stammverzeichnis des Projektverzeichnisses der Eclipse.
import java.io.BufferedReader;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.IOException;BufferedReader br;try{
br =newBufferedReader(newFileReader("/fileToRead.txt"));try{String x;while((x = br.readLine())!=null){// Printing out each line in the fileSystem.out.println(x);}}catch(IOException e){
e.printStackTrace();}}catch(FileNotFoundException e){System.out.println(e);
e.printStackTrace();}
Dies ist im Grunde genau das Gleiche wie die Antwort von Jesus Ramos, außer dass File anstelle von FileReader plus Iteration verwendet wird, um den Inhalt der Datei zu durchlaufen.
Scanner in =newScanner(newFile("filename.txt"));while(in.hasNext()){// Iterates each line in the fileString line = in.nextLine();// Do something with line}
in.close();// Don't forget to close resource leaks
File vs FileReader: Bei einem FileReader muss die Datei vorhanden sein und die Betriebssystemberechtigungen müssen den Zugriff ermöglichen. Mit einer Datei ist es möglich, diese Berechtigungen zu testen oder zu überprüfen, ob es sich bei der Datei um ein Verzeichnis handelt. Die Datei hat nützliche Funktionen: isFile (), isDirectory (), listFiles (), canExecute (), canRead (), canWrite (), existiert (), mkdir (), delete (). File.createTempFile () schreibt in das temporäre Standardverzeichnis des Systems. Diese Methode gibt ein Dateiobjekt zurück, das zum Öffnen von FileOutputStream-Objekten usw. verwendet werden kann. Quelle
ThisClark
7
Die gepufferten Stream-Klassen sind in der Praxis viel leistungsfähiger, so dass die NIO.2-API Methoden enthält, die diese Stream-Klassen speziell zurückgeben, teilweise um Sie zu ermutigen, immer gepufferte Streams in Ihrer Anwendung zu verwenden.
Hier ist ein Beispiel:
Path path =Paths.get("/myfolder/myfile.ext");try(BufferedReader reader =Files.newBufferedReader(path)){// Read from the streamString currentLine =null;while((currentLine = reader.readLine())!=null)//do your code here}catch(IOException e){// Handle file I/O exception...}
Dies schlägt für mich unter Android 4.4 fehl. Es werden nur 1024 Bytes gelesen. YMMV.
Roger Keays
3
Ich sehe es noch nicht in den anderen Antworten erwähnt. Wenn "Best" jedoch Geschwindigkeit bedeutet, bietet die neue Java-E / A (NIO) möglicherweise die schnellste Leistung, ist jedoch für Lernende nicht immer am einfachsten herauszufinden.
Sie sollten angegeben haben, wie es gemacht wird und keinen Link geben, dem Sie folgen sollen
Orar
3
Der einfachste Weg, Daten aus einer Datei in Java zu lesen, besteht darin, die Datei- Klasse zum Lesen der Datei und die Scanner- Klasse zum Lesen des Inhalts der Datei zu verwenden.
publicstaticvoid main(String args[])throwsException{File f =newFile("input.txt");
takeInputIn2DArray(f);}publicstaticvoid takeInputIn2DArray(File f)throwsException{Scanner s =newScanner(f);int a[][]=newint[20][20];for(int i=0; i<20; i++){for(int j=0; j<20; j++){
a[i][j]= s.nextInt();}}}
PS: Vergiss nicht, java.util zu importieren. *; damit der Scanner funktioniert.
Dies ist möglicherweise nicht die genaue Antwort auf die Frage. Es ist nur eine andere Möglichkeit, eine Datei zu lesen, bei der Sie den Pfad zu Ihrer Datei in Ihrem Java-Code nicht explizit angeben und ihn stattdessen als Befehlszeilenargument lesen.
Ich denke, readAllBytes ist schneller und präziser, weil es keine neue Zeile durch ersetzt \nund auch keine neue Zeile sein kann \r\n. Es hängt von Ihren Bedürfnissen ab, welches geeignet ist.
Sie können dies nicht für "jede gewünschte Datei" verwenden. Sie können es nur für Ressourcen verwenden, die in die JAR- oder WAR-Datei gepackt wurden.
try{File f =newFile("filename.txt");Scanner r =newScanner(f);while(r.hasNextLine()){String data = r.nextLine();JOptionPane.showMessageDialog(data);}
r.close();}catch(FileNotFoundException ex){JOptionPane.showMessageDialog("Error occurred");
ex.printStackTrace();}
Viel schneller, ich bezweifle es, wenn Sie einfache String-Verkettung anstelle eines StringBuilder verwenden ...
PhiLho
6
Ich denke, der Hauptgeschwindigkeitsgewinn ergibt sich aus dem Einlesen von 1 MB (1024 * 1024) Blöcken. Sie können dies jedoch auch einfach tun, indem Sie 1024 * 1024 als zweites Argument an den BufferedReader-Konstruktor übergeben.
gb96
3
Ich glaube nicht, dass dies überhaupt getestet wird. Wenn Sie +=auf diese Weise verwenden, erhalten Sie eine quadratische (!) Komplexität für eine Aufgabe, die linear komplex sein sollte. Dadurch wird nach Dateien über einige MB gecrawlt. Um dies zu umgehen, sollten Sie entweder die Textblöcke in einer Liste <string> aufbewahren oder den oben genannten Stringbuilder verwenden.
kritzikratzi
5
Viel schneller als was? Es ist mit Sicherheit nicht schneller als das Anhängen an einen StringBuffer. -1
Marquis von Lorne
1
@ gb96 Ich dachte dasselbe über Puffergrößen, aber das detaillierte Experiment in dieser Frage ergab überraschende Ergebnisse in einem ähnlichen Kontext: Ein 16-KB-Puffer war konsistent und merklich schneller.
Chiastic-Sicherheit
-3
String fileName ='yourFileFullNameWithPath';File file =newFile(fileName);// Creates a new file object for your fileFileReader fr =newFileReader(file);// Creates a Reader that you can use to read the contents of a file read your fileBufferedReader br =newBufferedReader(fr);//Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
Der obige Satz von Zeilen kann in eine einzelne Zeile geschrieben werden als:
Hinzufügen zum String Builder (Wenn Ihre Datei sehr groß ist, wird empfohlen, den String Builder zu verwenden, andernfalls verwenden Sie ein normales String-Objekt.)
try{StringBuilder sb =newStringBuilder();String line = br.readLine();while(line !=null){
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();}String everything = sb.toString();}finally{
br.close();}
Antworten:
ASCII ist eine TEXT-Datei, die Sie
Readers
zum Lesen verwenden würden. Java unterstützt auch das Lesen aus einer Binärdatei mitInputStreams
. Wenn die gelesenen Dateien sehr groß sind, sollten Sie aBufferedReader
über a verwendenFileReader
, um die Leseleistung zu verbessern.Lesen Sie diesen Artikel über die Verwendung von a
Reader
Ich würde Ihnen auch empfehlen, dieses wunderbare (und dennoch kostenlose) Buch namens Thinking In Java herunterzuladen und zu lesen
In Java 7 :
(docs) oder
(docs)
In Java 8 :
(docs)
quelle
Files.lines(…).forEach(…)
behält die Reihenfolge der Zeilen nicht bei, wird jedoch parallel ausgeführt, @Dash. Wenn die Bestellung wichtig ist, können Sie verwendenFiles.lines(…).forEachOrdered(…)
, wodurch die Bestellung erhalten bleiben soll (wurde jedoch nicht überprüft).Files.lines(...).forEach(...)
parallel ausgeführt wird? Ich dachte, dies sei nur dann der Fall, wenn Sie den Stream explizit parallel verwendenFiles.lines(...).parallel().forEach(...)
.forEach
keine Bestellung garantiert wird und der Grund eine einfache Parallelisierung ist. Wenn die Ordnung erhalten bleiben soll, verwenden SieforEachOrdered
.Meine Lieblingsmethode zum Lesen einer kleinen Datei ist die Verwendung eines BufferedReader und eines StringBuilder. Es ist sehr einfach und auf den Punkt gebracht (obwohl nicht besonders effektiv, aber für die meisten Fälle gut genug):
Einige haben darauf hingewiesen, dass Sie nach Java 7 die Funktionen zum Ausprobieren von Ressourcen (dh zum automatischen Schließen) verwenden sollten:
Wenn ich solche Zeichenfolgen lese, möchte ich normalerweise sowieso eine Zeichenfolgenbehandlung pro Zeile durchführen, also gehe ich zu dieser Implementierung.
Wenn ich jedoch nur eine Datei in einen String einlesen möchte, verwende ich immer Apache Commons IO mit der Klasse IOUtils.toString (). Die Quelle können Sie hier einsehen:
http://www.docjar.com/html/api/org/apache/commons/io/IOUtils.java.html
Und noch einfacher mit Java 7:
quelle
code
while (Zeile! = null) {sb.append (Zeile); line = br.readLine (); // Neue Zeile nur hinzufügen, wenn curline NICHT die letzte Zeile ist .. if (line! = Null) {sb.append ("\ n"); }}code
Am einfachsten ist es, die
Scanner
Klasse in Java und das FileReader-Objekt zu verwenden. Einfaches Beispiel:Scanner
Es gibt verschiedene Methoden zum Einlesen von Zeichenfolgen, Zahlen usw. Weitere Informationen hierzu finden Sie auf der Java-Dokumentationsseite.Zum Beispiel den gesamten Inhalt in ein
String
:Wenn Sie eine bestimmte Codierung benötigen, können Sie diese anstelle von
FileReader
:quelle
BufferedReader
while ((line = br.readLine()) != null) { sb.append(line); }
?Hier ist eine einfache Lösung:
quelle
Hier ist eine andere Möglichkeit, ohne externe Bibliotheken zu verwenden:
quelle
Ich musste die verschiedenen Wege vergleichen. Ich werde meine Ergebnisse kommentieren, aber kurz gesagt, der schnellste Weg ist, einen einfachen alten BufferedInputStream über einen FileInputStream zu verwenden. Wenn viele Dateien gelesen werden müssen, reduzieren drei Threads die Gesamtausführungszeit auf ungefähr die Hälfte. Wenn Sie jedoch mehr Threads hinzufügen, wird die Leistung schrittweise beeinträchtigt, bis die Fertigstellung mit zwanzig Threads dreimal länger dauert als mit nur einem Thread.
Die Annahme ist, dass Sie eine Datei lesen und mit ihrem Inhalt etwas Sinnvolles tun müssen. In den Beispielen werden hier Zeilen aus einem Protokoll gelesen und diejenigen gezählt, die Werte enthalten, die einen bestimmten Schwellenwert überschreiten. Ich gehe also davon aus, dass der Einzeiler Java 8
Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))
keine Option ist.Ich habe auf Java 1.8, Windows 7 und sowohl SSD- als auch HDD-Laufwerken getestet.
Ich habe sechs verschiedene Implementierungen geschrieben:
rawParse : Verwenden Sie BufferedInputStream über einen FileInputStream und schneiden Sie dann die byteweisen Zeilen aus. Dies übertraf jeden anderen Single-Thread-Ansatz, kann jedoch für Nicht-ASCII-Dateien sehr unpraktisch sein.
lineReaderParse : Verwenden Sie einen BufferedReader über einem FileReader, lesen Sie Zeile für Zeile, teilen Sie Zeilen, indem Sie String.split () aufrufen. Dies ist ungefähr 20% langsamer als rawParse.
lineReaderParseParallel : Dies ist dasselbe wie lineReaderParse, verwendet jedoch mehrere Threads. Dies ist in allen Fällen die schnellste Option insgesamt.
nioFilesParse : Verwenden Sie java.nio.files.Files.lines ()
nioAsyncParse : Verwenden Sie einen AsynchronousFileChannel mit einem Completion-Handler und einem Thread-Pool.
nioMemoryMappedParse : Verwenden Sie eine Speicherzuordnungsdatei. Dies ist wirklich eine schlechte Idee, da die Ausführungszeiten mindestens dreimal länger sind als bei jeder anderen Implementierung.
Dies sind die durchschnittlichen Zeiten für das Lesen von 204 Dateien mit jeweils 4 MB auf einem Quad-Core i7- und SSD-Laufwerk. Die Dateien werden im laufenden Betrieb generiert, um ein Zwischenspeichern der Festplatte zu vermeiden.
Ich fand einen kleineren Unterschied als erwartet zwischen der Ausführung auf einer SSD oder einem Festplattenlaufwerk, da die SSD ungefähr 15% schneller ist. Dies kann daran liegen, dass die Dateien auf einer nicht fragmentierten Festplatte generiert und nacheinander gelesen werden. Daher kann das sich drehende Laufwerk fast wie eine SSD funktionieren.
Ich war von der geringen Leistung der nioAsyncParse-Implementierung überrascht. Entweder habe ich etwas falsch implementiert oder die Multi-Thread-Implementierung mit NIO und einem Completion-Handler führt die gleiche (oder sogar schlechtere) Leistung aus wie eine Single-Thread-Implementierung mit der java.io-API. Darüber hinaus ist die asynchrone Analyse mit einem CompletionHandler in Codezeilen viel länger und schwierig korrekt zu implementieren als eine direkte Implementierung in alten Streams.
Jetzt die sechs Implementierungen, gefolgt von einer Klasse, die sie alle enthält, sowie einer parametrierbaren main () -Methode, mit der mit der Anzahl der Dateien, der Dateigröße und dem Grad der Parallelität gespielt werden kann. Beachten Sie, dass die Größe der Dateien plus plus 20% variiert. Dies dient dazu, Auswirkungen zu vermeiden, da alle Dateien genau dieselbe Größe haben.
rawParse
lineReaderParse
lineReaderParseParallel
nioFilesParse
nioAsyncParse
VOLLSTÄNDIG LAUFBARE UMSETZUNG ALLER FÄLLE
https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java
quelle
Hier sind die drei funktionierenden und getesteten Methoden:
Verwenden von
BufferedReader
Verwenden von
Scanner
Verwenden von
FileReader
Lesen Sie die gesamte Datei ohne Schleife mit der
Scanner
Klassequelle
java.nio.file.Files
? Wir können jetzt nur verwendenreadAllLines
,readAllBytes
undlines
.Die darin enthaltenen Methoden
org.apache.commons.io.FileUtils
können auch sehr praktisch sein, z.quelle
Was möchten Sie mit dem Text machen? Ist die Datei klein genug, um in den Speicher zu passen? Ich würde versuchen, den einfachsten Weg zu finden, um die Datei für Ihre Bedürfnisse zu handhaben. Die FileUtils-Bibliothek ist dafür sehr gut geeignet.
quelle
org.apache.commons.io.FileUtils
. Der Google-Link kann den Inhalt im Laufe der Zeit ändern, da sich die am weitesten verbreitete Bedeutung ändert. Dies entspricht jedoch seiner Abfrage und sieht korrekt aus.readLines(String)
undreadLines(File)
wird zugunsten von veraltetreadLines(File, Charset)
. Die Codierung kann auch als Zeichenfolge angegeben werden.Ich habe 15 Möglichkeiten zum Lesen einer Datei in Java dokumentiert und sie dann mit verschiedenen Dateigrößen auf Geschwindigkeit getestet - von 1 KB bis 1 GB. Hier sind die drei wichtigsten Möglichkeiten, dies zu tun:
java.nio.file.Files.readAllBytes()
Getestet für Java 7, 8 und 9.
java.io.BufferedReader.readLine()
Getestet für Java 7, 8, 9.
java.nio.file.Files.lines()
Dies wurde getestet, um in Java 8 und 9 zu funktionieren, funktioniert jedoch aufgrund der Lambda-Ausdrucksanforderung nicht in Java 7.
quelle
Im Folgenden finden Sie einen Einzeiler, wie Sie dies auf Java 8-Weise tun können. Angenommen, die
text.txt
Datei befindet sich im Stammverzeichnis des Projektverzeichnisses der Eclipse.quelle
Verwenden von BufferedReader:
quelle
Dies ist im Grunde genau das Gleiche wie die Antwort von Jesus Ramos, außer dass File anstelle von FileReader plus Iteration verwendet wird, um den Inhalt der Datei zu durchlaufen.
... wirft
FileNotFoundException
quelle
Die gepufferten Stream-Klassen sind in der Praxis viel leistungsfähiger, so dass die NIO.2-API Methoden enthält, die diese Stream-Klassen speziell zurückgeben, teilweise um Sie zu ermutigen, immer gepufferte Streams in Ihrer Anwendung zu verwenden.
Hier ist ein Beispiel:
Sie können diesen Code ersetzen
mit
Ich empfehle diesen Artikel, um die Hauptanwendungen von Java NIO und IO zu lernen.
quelle
Wahrscheinlich nicht so schnell wie bei gepufferten E / A, aber ziemlich knapp:
Das
\Z
Muster gibt an,Scanner
dass das Trennzeichen EOF ist.quelle
if(scanner.hasNext()) content = scanner.next();
Ich sehe es noch nicht in den anderen Antworten erwähnt. Wenn "Best" jedoch Geschwindigkeit bedeutet, bietet die neue Java-E / A (NIO) möglicherweise die schnellste Leistung, ist jedoch für Lernende nicht immer am einfachsten herauszufinden.
http://download.oracle.com/javase/tutorial/essential/io/file.html
quelle
Der einfachste Weg, Daten aus einer Datei in Java zu lesen, besteht darin, die Datei- Klasse zum Lesen der Datei und die Scanner- Klasse zum Lesen des Inhalts der Datei zu verwenden.
PS: Vergiss nicht, java.util zu importieren. *; damit der Scanner funktioniert.
quelle
Guave bietet hierfür einen Einzeiler:
quelle
Dies ist möglicherweise nicht die genaue Antwort auf die Frage. Es ist nur eine andere Möglichkeit, eine Datei zu lesen, bei der Sie den Pfad zu Ihrer Datei in Ihrem Java-Code nicht explizit angeben und ihn stattdessen als Befehlszeilenargument lesen.
Mit dem folgenden Code:
Führen Sie es einfach aus mit:
Dies würde den Inhalt der lesen
input.txt
und auf Ihrer Konsole drucken.Sie können auch festlegen, dass Sie
System.out.println()
über die Befehlszeile wie folgt in eine bestimmte Datei schreiben:Dies würde lesen
input.txt
und schreibenoutput.txt
.quelle
Sie können readAllLines und die
join
Methode verwenden, um den gesamten Dateiinhalt in einer Zeile abzurufen :Standardmäßig wird die UTF-8-Codierung verwendet, mit der ASCII-Daten korrekt gelesen werden.
Sie können auch readAllBytes verwenden:
Ich denke, readAllBytes ist schneller und präziser, weil es keine neue Zeile durch ersetzt
\n
und auch keine neue Zeile sein kann\r\n
. Es hängt von Ihren Bedürfnissen ab, welches geeignet ist.quelle
Verwenden Sie für JSF-basierte Maven-Webanwendungen einfach ClassLoader und den
Resources
Ordner, um eine beliebige Datei einzulesen:Fügen Sie die Apache Commons IO-Abhängigkeit in Ihr POM ein:
Verwenden Sie den folgenden Code, um ihn zu lesen (z. B. liest er eine .json-Datei ein):
Sie können dies auch für Textdateien, Eigenschaftendateien, XSD- Schemas usw. tun .
quelle
Kakteen geben Ihnen einen deklarativen Einzeiler :
quelle
Verwenden Sie Java Kiss, wenn es um die Einfachheit der Struktur geht:
quelle
Verwenden Sie einfach Java 8 Stream.
quelle
quelle
Die intuitivste Methode wird in Java 11 eingeführt
Files.readString
PHP hat diesen Luxus von vor Jahrzehnten! ☺
quelle
Dieser von mir programmierte Code ist für sehr große Dateien viel schneller:
quelle
+=
auf diese Weise verwenden, erhalten Sie eine quadratische (!) Komplexität für eine Aufgabe, die linear komplex sein sollte. Dadurch wird nach Dateien über einige MB gecrawlt. Um dies zu umgehen, sollten Sie entweder die Textblöcke in einer Liste <string> aufbewahren oder den oben genannten Stringbuilder verwenden.Der obige Satz von Zeilen kann in eine einzelne Zeile geschrieben werden als:
Hinzufügen zum String Builder (Wenn Ihre Datei sehr groß ist, wird empfohlen, den String Builder zu verwenden, andernfalls verwenden Sie ein normales String-Objekt.)
quelle