it-swarm.com.de

Lesen einer Nur-Text-Datei in Java

Es scheint verschiedene Möglichkeiten zu geben, Daten von Dateien in Java zu lesen und zu schreiben.

Ich möchte ASCII Daten aus einer Datei lesen. Was sind die möglichen Wege und deren Unterschiede?

885

Da ASCII eine TEXT-Datei ist, würden Sie Readers zum Lesen verwenden. Java unterstützt auch das Lesen aus einer Binärdatei mit InputStreams . Wenn die zu lesenden Dateien sehr groß sind, sollten Sie ein BufferedReader auf ein FileReader setzen, um die Leseleistung zu verbessern.

Lesen Sie diesen Artikel wie man ein Reader benutzt

Ich würde Ihnen auch empfehlen, dieses wunderbare (noch kostenlose) Buch mit dem Titel Thinking In Java herunterzuladen und zu lesen

In Java 7 :

new String(Files.readAllBytes(...))

(docs) oder

Files.readAllLines(...)

(docs)

In Java 8 :

Files.lines(..).forEach(...)

(docs)

533

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 in den meisten Fällen gut genug):

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
    StringBuilder sb = new StringBuilder();
    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 try-with-resources (d. H. Automatisch schließen) Funktionen verwenden sollten:

try(BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
}

Wenn ich solche Strings lese, möchte ich normalerweise sowieso ein wenig mit Strings pro Zeile umgehen, also greife ich zu dieser Implementierung.

Auch wenn ich eigentlich nur eine Datei in einen String einlesen möchte, verwende ich immer Apache Commons IO mit der Klasse IOUtils.toString (). Hier können Sie sich die Quelle ansehen:

http://www.docjar.com/html/api/org/Apache/commons/io/IOUtils.Java.html

FileInputStream inputStream = new FileInputStream("foo.txt");
try {
    String everything = IOUtils.toString(inputStream);
} finally {
    inputStream.close();
}

Und noch einfacher mit Java 7:

try(FileInputStream inputStream = new FileInputStream("foo.txt")) {     
    String everything = IOUtils.toString(inputStream);
    // do something with everything string
}
670
Knubo

Am einfachsten ist es, die Klasse Scanner in Java und das FileReader-Objekt zu verwenden. Einfaches Beispiel:

Scanner in = new Scanner(new FileReader("filename.txt"));

Scanner bietet verschiedene Methoden zum Einlesen von Zeichenfolgen, Zahlen usw. Weitere Informationen hierzu finden Sie auf der Dokumentationsseite Java.

Zum Beispiel den gesamten Inhalt in ein String einlesen:

StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
    sb.append(in.next());
}
in.close();
outString = sb.toString();

Auch wenn Sie eine bestimmte Codierung benötigen, können Sie diese anstelle von FileReader verwenden:

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)
133
Jesus Ramos

Hier ist eine einfache Lösung:

String content;

content = new String(Files.readAllBytes(Paths.get("sample.txt")));
75
Nery Jr

Hier ist eine andere Möglichkeit, ohne externe Bibliotheken zu verwenden:

import Java.io.File;
import Java.io.FileReader;
import Java.io.IOException;

public String readFile(String filename)
{
    String content = null;
    File file = new File(filename); // For example, foo.txt
    FileReader reader = null;
    try {
        reader = new FileReader(file);
        char[] chars = new char[(int) file.length()];
        reader.read(chars);
        content = new String(chars);
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(reader != null){
            reader.close();
        }
    }
    return content;
}
57
Grimy

Ich musste die verschiedenen Wege vergleichen. Ich werde auf meine Ergebnisse eingehen, aber der schnellste Weg besteht darin, einen einfachen alten BufferedInputStream über einen FileInputStream zu verwenden. Wenn viele Dateien gelesen werden müssen, wird durch drei Threads die Gesamtausführungszeit auf ungefähr die Hälfte reduziert, aber durch Hinzufügen von mehr Threads wird die Leistung nach und nach beeinträchtigt, bis der Vorgang 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 anfangen 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 SSD- und HDD-Laufwerken getestet.

Ich habe sechs verschiedene Implementierungen geschrieben:

rawParse : Verwenden Sie BufferedInputStream über einem FileInputStream und schneiden Sie dann byteweise lesende 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 zeilenweise, teilen Sie die 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 speicherabgebildete Datei. 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.

rawParse                11.10 sec
lineReaderParse         13.86 sec
lineReaderParseParallel  6.00 sec
nioFilesParse           13.52 sec
nioAsyncParse           16.06 sec
nioMemoryMappedParse    37.68 sec

Ich fand einen Unterschied, der kleiner war als ich erwartet hatte, 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 erstellt und nacheinander gelesen werden. Daher kann das sich drehende Laufwerk fast wie eine SSD arbeiten.

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 funktioniert genauso (oder sogar noch schlechter) als eine Single-Thread-Implementierung mit der Java.io-API. Darüber hinaus ist das asynchrone Parsen mit einem CompletionHandler in Codezeilen viel länger und schwieriger korrekt zu implementieren als eine direkte Implementierung in alten Streams.

Nun folgen die sechs Implementierungen, gefolgt von einer Klasse, die alle enthält, sowie eine parametrierbare main () -Methode, mit der Sie mit der Anzahl der Dateien, der Dateigröße und dem Grad der gleichzeitigen Verwendung spielen können. Beachten Sie, dass die Größe der Dateien plus minus 20% variiert. Dies dient zur Vermeidung von Effekten, da alle Dateien genau die gleiche Größe haben.

rawParse

public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    overrunCount = 0;
    final int dl = (int) ';';
    StringBuffer lineBuffer = new StringBuffer(1024);
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileInputStream fin = new FileInputStream(fl);
        BufferedInputStream bin = new BufferedInputStream(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();
    }
}

public final void doSomethingWithRawLine(String line) throws ParseException {
    // What to do for each line
    int fieldNumber = 0;
    final int len = line.length();
    StringBuffer fieldBuffer = new StringBuffer(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) {
                    case 0:
                        Date dt = fmt.parse(fieldValue);
                        fieldNumber++;
                        break;
                    case 1:
                        double d = Double.parseDouble(fieldValue);
                        fieldNumber++;
                        break;
                    case 2:
                        int t = Integer.parseInt(fieldValue);
                        fieldNumber++;
                        break;
                    case 3:
                        if (fieldValue.equals("overrun"))
                            overrunCount++;
                        break;
                }
            }
            fieldBuffer.setLength(0);
        }
        else {
            fieldBuffer.append(c);
        }
    }
}

lineReaderParse

public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    String line;
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileReader frd = new FileReader(fl);
        BufferedReader brd = new BufferedReader(frd);

        while ((line=brd.readLine())!=null)
            doSomethingWithLine(line);
        brd.close();
        frd.close();
    }
}

public final void doSomethingWithLine(String line) throws ParseException {
    // Example of what to do for each line
    String[] 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++;
}

lineReaderParseParallel

public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
    Thread[] pool = new Thread[degreeOfParalelism];
    int batchSize = numberOfFiles / degreeOfParalelism;
    for (int b=0; b<degreeOfParalelism; b++) {
        pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
        pool[b].start();
    }
    for (int b=0; b<degreeOfParalelism; b++)
        pool[b].join();
}

class LineReaderParseThread extends Thread {

    private String targetDir;
    private int fileFrom;
    private int fileTo;
    private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private int overrunCounter = 0;

    public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
        this.targetDir = targetDir;
        this.fileFrom = fileFrom;
        this.fileTo = fileTo;
    }

    private void doSomethingWithTheLine(String line) throws ParseException {
        String[] fields = line.split(DL);
        Date dt = fmt.parse(fields[0]);
        double d = Double.parseDouble(fields[1]);
        int t = Integer.parseInt(fields[2]);
        if (fields[3].equals("overrun"))
            overrunCounter++;
    }

    @Override
    public void run() {
        String line;
        for (int f=fileFrom; f<fileTo; f++) {
            File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
            try {
            FileReader frd = new FileReader(fl);
            BufferedReader brd = new BufferedReader(frd);
            while ((line=brd.readLine())!=null) {
                doSomethingWithTheLine(line);
            }
            brd.close();
            frd.close();
            } catch (IOException | ParseException ioe) { }
        }
    }
}

nioFilesParse

public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    for (int f=0; f<numberOfFiles; f++) {
        Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        Consumer<String> action = new LineConsumer();
        Stream<String> lines = Files.lines(ph);
        lines.forEach(action);
        lines.close();
    }
}


class LineConsumer implements Consumer<String> {

    @Override
    public void accept(String line) {

        // What to do for each line
        String[] 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

public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
    ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
    ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<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 = new BufferConsumer(byteBuffers, fileName, bufferSize);
        channel.read(consumer.buffer(), 0l, channel, consumer);
    }
    consumerThreads.acquire(numberOfThreads);
}


class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {

        private ConcurrentLinkedQueue<ByteBuffer> buffers;
        private ByteBuffer bytes;
        private String file;
        private StringBuffer chars;
        private int limit;
        private long position;
        private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
            buffers = byteBuffers;
            bytes = buffers.poll();
            if (bytes==null)
                bytes = ByteBuffer.allocate(bufferSize);

            file = fileName;
            chars = new StringBuffer(bufferSize);
            frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            limit = bufferSize;
            position = 0l;
        }

        public ByteBuffer buffer() {
            return bytes;
        }

        @Override
        public synchronized void completed(Integer result, AsynchronousFileChannel channel) {

            if (result!=-1) {
                bytes.flip();
                final int 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);
            }
        }

        @Override
        public void failed(Throwable e, AsynchronousFileChannel channel) {
        }
};

VOLLSTÄNDIGE DURCHFÜHRUNG ALLER FÄLLE

https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.Java

30
Serg M Ten

Hier sind die drei arbeitenden und getesteten Methoden:

BufferedReader verwenden

package io;
import Java.io.*;
public class ReadFromFile2 {
    public static void main(String[] args)throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.Java");
        BufferedReader br = new BufferedReader(new FileReader(file));
        String st;
        while((st=br.readLine()) != null){
            System.out.println(st);
        }
    }
}

Scanner verwenden

package io;

import Java.io.File;
import Java.util.Scanner;

public class ReadFromFileUsingScanner {
    public static void main(String[] args) throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.Java");
        Scanner sc = new Scanner(file);
        while(sc.hasNextLine()){
            System.out.println(sc.nextLine());
        }
    }
}

FileReader verwenden

package io;
import Java.io.*;
public class ReadingFromFile {

    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("C:\\Users\\pankaj\\Desktop\\test.Java");
        int i;
        while ((i=fr.read()) != -1){
            System.out.print((char) i);
        }
    }
}

Lesen Sie die gesamte Datei ohne Schleife mit der Klasse Scanner

package io;

import Java.io.File;
import Java.io.FileNotFoundException;
import Java.util.Scanner;

public class ReadingEntireFileWithoutLoop {

    public static void main(String[] args) throws FileNotFoundException {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.Java");
        Scanner sc = new Scanner(file);
        sc.useDelimiter("\\Z");
        System.out.println(sc.next());
    }
}
23
pankaj

Die Methoden in org.Apache.commons.io.FileUtils können auch sehr praktisch sein, z.

_/**
 * Reads the contents of a file line by line to a List
 * of Strings using the default encoding for the VM.
 */
static List readLines(File file)
_
21
Claude

Was willst du 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 behandeln. Die FileUtils-Bibliothek ist dafür sehr gut geeignet.

for(String line: FileUtils.readLines("my-text-file"))
    System.out.println(line);
17
Peter Lawrey

Ich habe 15 Möglichkeiten, eine Datei in Java zu lesen dokumentiert und sie dann auf Geschwindigkeit mit verschiedenen Dateigrößen getestet - von 1 KB bis 1 GB. Hier sind die drei wichtigsten Möglichkeiten, dies zu tun:

  1. Java.nio.file.Files.readAllBytes()

    Funktioniert getestet in Java 7, 8 und 9.

    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-10KB.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.io.BufferedReader.readLine()

    Funktioniert getestet in Java 7, 8, 9.

    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-10KB.txt";
        FileReader fileReader = new FileReader(fileName);
    
        try (BufferedReader bufferedReader = new BufferedReader(fileReader)) {
          String line;
          while((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
          }
        }
      }
    }
    
  3. 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.

    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-10KB.txt";
        File file = new File(fileName);
    
        try (Stream linesStream = Files.lines(file.toPath())) {
          linesStream.forEach(line -> {
            System.out.println(line);
          });
        }
      }
    }
    
10
gomisha

Im Folgenden finden Sie einen Einzeiler für die Vorgehensweise auf die Java 8-Weise. Angenommen, die Datei text.txt befindet sich im Stammverzeichnis des Projektverzeichnisses von Eclipse.

Files.lines(Paths.get("text.txt")).collect(Collectors.toList());
9
Zeus

Dies ist im Grunde genau das Gleiche wie die Antwort von Jesus Ramos, außer dass File anstelle von FileReader plus Iteration, um den Inhalt der Datei zu durchlaufen.

Scanner in = new Scanner(new File("filename.txt"));

while (in.hasNext()) { // Iterates each line in the file
    String line = in.nextLine();
    // Do something with line
}

in.close(); // Don't forget to close resource leaks

... wirft FileNotFoundException

7
ThisClark

Verwenden von BufferedReader:

import Java.io.BufferedReader;
import Java.io.FileNotFoundException;
import Java.io.FileReader;
import Java.io.IOException;

BufferedReader br;
try {
    br = new BufferedReader(new FileReader("/fileToRead.txt"));
    try {
        String x;
        while ( (x = br.readLine()) != null ) {
            // Printing out each line in the file
            System.out.println(x);
        }
    }
    catch (IOException e) {
        e.printStackTrace();
    }
}
catch (FileNotFoundException e) {
    System.out.println(e);
    e.printStackTrace();
}
7
Neo

Wahrscheinlich nicht so schnell wie bei gepufferten I/O, aber ziemlich knapp:

    String content;
    try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
        content = scanner.next();
    }

Das Muster \Z teilt dem Scanner mit, dass das Trennzeichen EOF ist.

6
David Soroko

Die gepufferten Stream-Klassen sind in der Praxis wesentlich leistungsfähiger, so dass die NIO.2-API Methoden enthält, die diese Stream-Klassen speziell zurückgeben, um Sie zum Teil 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 stream
    String currentLine = null;
    while ((currentLine = reader.readLine()) != null)
        //do your code here
} catch (IOException e) {
    // Handle file I/O exception...
}

Sie können diesen Code ersetzen

BufferedReader reader = Files.newBufferedReader(path);

mit

BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));

Ich empfehle diesen Artikel, um die Hauptanwendungen von Java NIO und IO zu lernen.

4
Imar

Ich sehe es noch nicht in den anderen Antworten erwähnt. Aber wenn "Best" Geschwindigkeit bedeutet, bietet das neue Java I/O (NIO) möglicherweise die schnellste Leistung, ist aber für jemanden, der etwas lernt, nicht immer die einfachste.

http://download.Oracle.com/javase/tutorial/essential/io/file.html

3
jzd

Der einfachste Weg, Daten aus einer Datei in Java zu lesen, besteht darin, die Klasse File zum Lesen der Datei und die Klasse Scanner zum Lesen der Datei zu verwenden Inhalt der Datei.

public static void main(String args[])throws Exception
{
   File f = new File("input.txt");
   takeInputIn2DArray(f);
}

public static void takeInputIn2DArray(File f) throws Exception
{
    Scanner s = new Scanner(f);
    int a[][] = new int[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.

3
anadir47

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 nicht explizit in Ihrem Java Code angeben und sie stattdessen als Befehlszeilenargument lesen.

Mit dem folgenden Code

import Java.io.BufferedReader;
import Java.io.InputStreamReader;
import Java.io.IOException;

public class InputReader{

    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s="";
        while((s=br.readLine())!=null){
            System.out.println(s);
        }
    }
}

mach einfach weiter und starte es mit:

Java InputReader < input.txt

Dies würde den Inhalt des input.txt lesen und auf Ihrer Konsole ausdrucken.

Sie können Ihr System.out.println() auch so einstellen, dass es über die Befehlszeile in eine bestimmte Datei schreibt:

Java InputReader < input.txt > output.txt

Dies würde aus input.txt lesen und in output.txt schreiben.

2
Adit A. Pillai

Guave liefert dafür einen Einzeiler:

import com.google.common.base.Charsets;
import com.google.common.io.Files;

String contents = Files.toString(filePath, Charsets.UTF_8);
2
rahul mehra

Sie können readAllLines und die join -Methode verwenden, um den gesamten Dateiinhalt in einer Zeile abzurufen:

String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));

Standardmäßig wird die UTF-8-Codierung verwendet, mit der ASCII Daten korrekt gelesen werden.

Sie können auch readAllBytes verwenden:

String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);

Ich denke, readAllBytes ist schneller und präziser, weil es die neue Zeile nicht durch \n ersetzt und auch die neue Zeile \r\n sein kann. Welches für Sie geeignet ist, hängt von Ihren Bedürfnissen ab.

2

Cactoos Geben Sie einen deklarativen Einzeiler:

new TextOf(new File("a.txt")).asString();
1
yegor256

Verwenden Sie für JSF-basierte Maven-Webanwendungen einfach ClassLoader und den Ordner Resources, um eine beliebige Datei einzulesen:

  1. Legen Sie eine beliebige Datei, die Sie lesen möchten, in den Ordner Resources.
  2. Fügen Sie die Abhängigkeit von Apache Commons IO in Ihren POM ein:

    <dependency>
        <groupId>org.Apache.commons</groupId>
        <artifactId>commons-io</artifactId>
        <version>1.3.2</version>
    </dependency>
    
  3. Verwenden Sie den folgenden Code, um ihn zu lesen (z. B. liest der folgende Code eine JSON-Datei ein):

    String metadata = null;
    FileInputStream inputStream;
    try {
    
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        inputStream = (FileInputStream) loader
                .getResourceAsStream("/metadata.json");
        metadata = IOUtils.toString(inputStream);
        inputStream.close();
    }
    catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return metadata;
    

Sie können dasselbe für Textdateien, .properties-Dateien, XSD Schemata usw. tun.

1
Fuzzy Analysis

Verwenden Sie Java kiss , wenn es um die Einfachheit der Struktur geht:

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}
0
Warren MacEvoy