Lettura di un file di testo semplice in Java


933

Sembra che ci siano diversi modi per leggere e scrivere i dati dei file in Java.

Voglio leggere i dati ASCII da un file. Quali sono i modi possibili e le loro differenze?


24
Sono anche in disaccordo con la chiusura come "non costruttiva". Fortunatamente, questo potrebbe essere chiuso come duplicato . Buone risposte, ad es. In Come creare una stringa dal contenuto di un file? , Qual è il modo più semplice per leggere un file in String? , Quali sono le classi più semplici per leggere i file?
Jonik,

Senza loop: {{{Scanner sc = nuovo scanner (file, "UTF-8"); sc.useDelimiter ( "$ ^"); // regex non corrisponde a nulla String text = sc.next (); sc.close (); }}}
Aivar,

3
è così interessante che non c'è niente come "read ()" in Python, per leggere l'intero file in una stringa
kommradHomer

2
Questo è il modo più semplice per farlo: mkyong.com/java/…
dellasavia

Risposte:


567

ASCII è un file TEXT da utilizzare Readersper la lettura. Java supporta anche la lettura da un file binario tramite InputStreams. Se i file letti sono enormi, allora si vorrebbe usare uno BufferedReadersopra a FileReaderper migliorare le prestazioni di lettura.

Leggi questo articolo su come usare aReader

Ti consiglio anche di scaricare e leggere questo meraviglioso libro (ancora gratuito) chiamato Thinking In Java

In Java 7 :

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

(documenti) o

Files.readAllLines(...)

(documenti)

In Java 8 :

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

(documenti)


14
La scelta di un Reader dipende davvero da ciò di cui hai bisogno per il contenuto del file. Se il file è piccolo (ish) e hai bisogno di tutto, è più veloce (benchmarkato da noi: 1,8-2x) usare semplicemente un FileReader e leggere tutto (o almeno blocchi abbastanza grandi). Se lo stai elaborando riga per riga, scegli BufferedReader.
Vlad

3
L'ordine delle righe verrà preservato quando si utilizza "Files.lines (..). ForEach (...)". La mia comprensione è che l'ordine sarà arbitrario dopo questa operazione.
Daniil Shevelev,

39
Files.lines(…).forEach(…)non conserva l'ordine delle linee ma viene eseguito in parallelo, @Dash. Se l'ordine è importante, è possibile utilizzare Files.lines(…).forEachOrdered(…), che dovrebbe preservare l'ordine (non verificato però).
Palec,

2
@Palec è interessante, ma puoi citare i documenti in cui si dice che Files.lines(...).forEach(...)viene eseguito in parallelo? Ho pensato che questo fosse solo il caso in cui hai esplicitamente reso lo stream parallelo usando Files.lines(...).parallel().forEach(...).
Klitos Kyriacou,

3
La mia formulazione originale non è a prova di proiettile, @KlitosKyriacou. Il punto è che forEachnon garantisce alcun ordine e il motivo è una facile parallelizzazione. Se l'ordine deve essere preservato, utilizzare forEachOrdered.
Palec,

687

Il mio modo preferito di leggere un piccolo file è usare un BufferedReader e un StringBuilder. È molto semplice e preciso (anche se non particolarmente efficace, ma abbastanza buono per la maggior parte dei casi):

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

Alcuni hanno sottolineato che dopo Java 7 dovresti usare try-with-resources (cioè la chiusura automatica):

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

Quando leggo stringhe come questa, di solito voglio comunque fare un po 'di gestione delle stringhe per riga, quindi seguo questa implementazione.

Anche se in realtà voglio solo leggere un file in una stringa, uso sempre Apache Commons IO con il metodo IOUtils.toString (). Puoi dare un'occhiata alla fonte qui:

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

E ancora più semplice con Java 7:

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

6
Ho apportato una piccola modifica per interrompere l'aggiunta di una nuova riga (\ n) se viene raggiunta l'ultima riga. code while (line! = null) {sb.append (line); line = br.readLine (); // Aggiungi nuova riga solo quando la curva NON è l'ultima riga .. if (line! = Null) {sb.append ("\ n"); }}code
Ramon Fincken,

2
Simile a IO IOUtils # toString () di Apache Common è sun.misc.IOUtils # readFully (), incluso nei JRE Sun / Oracle.
GB

3
Per prestazioni, chiamare sempre sb.append ('\ n') preferibilmente a sb.append ("\ n") poiché un carattere viene aggiunto a StringBuilder più velocemente di una stringa
gb96

2
FileReader può generare FileNotFoundException e BufferedRead può generare IOException, quindi è necessario catturarli.
Kamaci,

4
non è necessario utilizzare direttamente i lettori e nemmeno bisogno di ioutils. java7 ha incorporato metodi per leggere un intero file / tutte le righe: consultare docs.oracle.com/javase/7/docs/api/java/nio/file/… e docs.oracle.com/javase/7/docs/api / java / nio / file /…
kritzikratzi il

142

Il modo più semplice è utilizzare la Scannerclasse in Java e l'oggetto FileReader. Esempio semplice:

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

Scanner ha diversi metodi per leggere stringhe, numeri, ecc. Puoi cercare maggiori informazioni su questo nella pagina della documentazione di Java.

Ad esempio, leggendo l'intero contenuto in un String:

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

Inoltre, se hai bisogno di una codifica specifica, puoi usarla al posto di FileReader:

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)

28
while (in.hasNext ()) {System.out.println (in.next ()); }
Gene Bo,

16
@Hissain Ma molto più facile da usare diBufferedReader
Jesus Ramos

3
Deve circondarlo con provare Catch
Rahal Kanishka il

@JesusRamos Non proprio, perché la pensi così? Cosa c'è di più facile di questo while ((line = br.readLine()) != null) { sb.append(line); }?
Marchese di Lorne,

83

Ecco una soluzione semplice:

String content;

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

2
@Nery Jr, elegante e semplice
Mahmoud Saleh,

1
Il migliore e più semplice.
Dary,

57

Ecco un altro modo per farlo senza usare librerie esterne:

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

10
o usa "try-with-resources" try (Lettore FileReader = nuovo FileReader (file))
Hernán Eche

3
Ho notato il file.length (), quanto funziona bene con i file utf-16?
Wayne,

5
Questa tecnica presuppone che read () riempia il buffer; che il numero di caratteri è uguale al numero di byte; che il numero di byte si adatta alla memoria; e che il numero di byte rientri in un numero intero. -1
Marchese di Lorne,

1
@HermesTrismegistus Ho fornito quattro motivi per cui è sbagliato. StefanReich ha perfettamente ragione di essere d'accordo con me.
Marchese di Lorne,

35

Ho dovuto confrontare i diversi modi. Commenterò i miei risultati ma, in breve, il modo più veloce è quello di utilizzare un semplice BufferedInputStream su FileInputStream. Se è necessario leggere molti file, tre thread ridurranno il tempo di esecuzione totale a circa la metà, ma l'aggiunta di più thread peggiorerà progressivamente le prestazioni fino a quando non richiederà tre volte più tempo per completare con venti thread rispetto a un solo thread.

Il presupposto è che devi leggere un file e fare qualcosa di significativo con il suo contenuto. Negli esempi qui sta leggendo le righe da un registro e conta quelle che contengono valori che superano una certa soglia. Quindi presumo che il Java 8 da una rigaFiles.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) non sia una opzione.

Ho provato su Java 1.8, Windows 7 e su entrambe le unità SSD e HDD.

Ho scritto sei diverse implementazioni:

rawParse : usa BufferedInputStream su FileInputStream e quindi taglia le righe leggendo byte per byte. Questo ha superato qualsiasi altro approccio a thread singolo, ma può essere molto scomodo per i file non ASCII.

lineReaderParse : utilizzare un BufferedReader su un FileReader, leggere riga per riga, dividere le linee chiamando String.split (). Questo è approssimativamente il 20% più lento di rawParse.

lineReaderParseParallel : è uguale a lineReaderParse, ma utilizza diversi thread. Questa è l'opzione più veloce in assoluto in tutti i casi.

nioFilesParse : usa java.nio.files.Files.lines ()

nioAsyncParse : utilizza un AsynchronousFileChannel con un gestore di completamento e un pool di thread.

nioMemoryMappedParse : utilizza un file mappato in memoria. Questa è davvero una cattiva idea che porta a tempi di esecuzione almeno tre volte più lunghi di qualsiasi altra implementazione.

Questi sono i tempi medi per la lettura di 204 file di 4 MB ciascuno su un'unità quad-core i7 e SSD. I file vengono generati al volo per evitare la memorizzazione nella cache del disco.

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

Ho trovato una differenza più piccola di quanto mi aspettassi tra l'esecuzione su un SSD o un'unità HDD essendo l'SSD circa il 15% più veloce. Ciò può essere dovuto al fatto che i file vengono generati su un HDD non frammentato e vengono letti in sequenza, quindi l'unità di rotazione può funzionare quasi come un SSD.

Sono rimasto sorpreso dalle basse prestazioni dell'implementazione nioAsyncParse. O ho implementato qualcosa nel modo sbagliato o l'implementazione multi-thread utilizzando NIO e un gestore di completamento esegue lo stesso (o anche peggio) di un'implementazione a thread singolo con l'API java.io. Inoltre l'analisi asincrona con un CompletionHandler è molto più lunga in righe di codice e difficile da implementare correttamente rispetto a un'implementazione diretta su vecchi flussi.

Ora le sei implementazioni seguite da una classe che le contiene tutte più un metodo main () parametrizzabile che consente di giocare con il numero di file, dimensione del file e grado di concorrenza. Si noti che la dimensione dei file varia più meno il 20%. Questo per evitare effetti dovuti al fatto che tutti i file hanno esattamente le stesse dimensioni.

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

ATTUAZIONE COMPLETA E CORRETTA DI TUTTI I CASI

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


24

Ecco i tre metodi di lavoro e testati:

utilizzando BufferedReader

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

utilizzando Scanner

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

utilizzando FileReader

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

Leggi l'intero file senza un ciclo usando la Scannerclasse

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

1
Come dare il percorso se le cartelle sono presenti all'interno del progetto?
Kavipriya,

2
Che dire java.nio.file.Files? Ora possiamo semplicemente usare readAllLines, readAllBytese lines.
Claude Martin,

21

I metodi all'interno org.apache.commons.io.FileUtilspossono anche essere molto utili, ad esempio:

/**
 * 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)

O se preferisci Guava (una libreria più moderna e mantenuta attivamente), ha utilità simili nella sua classe Files . Semplici esempi in questa risposta .
Jonik,

1
o semplicemente usi il metodo integrato per ottenere tutte le righe: docs.oracle.com/javase/7/docs/api/java/nio/file/…
kritzikratzi

Il link sui beni comuni di Apache sembra morto.
kebs

17

Cosa vuoi fare con il testo? Il file è abbastanza piccolo da adattarsi alla memoria? Vorrei provare a trovare il modo più semplice di gestire il file per le tue esigenze. La libreria FileUtils è molto utile per questo.

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


@PeterLawrey probabilmente significa org.apache.commons.io.FileUtils. Il collegamento di Google può cambiare i contenuti nel tempo, poiché il significato più diffuso si sposta, ma questo corrisponde alla sua domanda e sembra corretto.
Palec,

2
Sfortunatamente, al giorno d'oggi non c'è readLines(String)e readLines(File)è deprecato a favore readLines(File, Charset). La codifica può essere fornita anche come stringa.
Palec,


12

Ho documentato 15 modi per leggere un file in Java e poi li ho testati per la velocità con varie dimensioni di file - da 1 KB a 1 GB e qui ci sono i tre principali modi per farlo:

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

    Testato per funzionare in Java 7, 8 e 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()

    Testato per funzionare 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()

    Questo è stato testato per funzionare in Java 8 e 9 ma non funzionerà in Java 7 a causa del requisito di espressione lambda.

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

9

Di seguito è riportato un esempio di come farlo nel modo Java 8. Supponendo che il text.txtfile sia nella directory principale del progetto di Eclipse.

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

7

Utilizzando 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

Questo è fondamentalmente lo stesso della risposta di Jesus Ramos, tranne con File anziché FileReader più iterazione per scorrere il contenuto del file.

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

... lancia FileNotFoundException


3
File vs FileReader: con un FileReader, il file deve esistere e le autorizzazioni del sistema operativo devono consentire l'accesso. Con un file è possibile testare tali autorizzazioni o verificare se il file è una directory. Il file ha funzioni utili: isFile (), isDirectory (), listFiles (), canExecute (), canRead (), canWrite (), exist (), mkdir (), delete (). File.createTempFile () scrive nella directory temporanea predefinita del sistema. Questo metodo restituirà un oggetto file che può essere utilizzato per aprire oggetti FileOutputStream, ecc. Source
ThisClark

7

Le classi di stream bufferizzate sono molto più performanti nella pratica, tanto che l'API NIO.2 include metodi che restituiscono specificamente queste classi di stream, in parte per incoraggiarti a usare sempre flussi bufferizzati nella tua applicazione.

Ecco un esempio:

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

È possibile sostituire questo codice

BufferedReader reader = Files.newBufferedReader(path);

con

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

Consiglio questo articolo per imparare gli usi principali di Java NIO e IO.


6

Probabilmente non veloce come con l'I / O bufferizzato, ma abbastanza conciso:

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

Il \Zmodello indica Scannerche il delimitatore è EOF.


1
Una risposta molto correlata, già esistente è di Jesus Ramos.
Palec,

1
Vero, dovrebbe essere: if(scanner.hasNext()) content = scanner.next();
David Soroko,

1
Questo non riesce per me su Android 4.4. Vengono letti solo 1024 byte. YMMV.
Roger Keays,


3

Il modo più semplice per leggere i dati da un file in Java è utilizzare la classe File per leggere il file e la classe Scanner per leggere il contenuto del file.

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: non dimenticare di importare java.util. *; affinché Scanner funzioni.


2

Guava fornisce un one-liner per questo:

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

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

2

Questa potrebbe non essere la risposta esatta alla domanda. È solo un altro modo di leggere un file in cui non specifichi esplicitamente il percorso del tuo file nel tuo codice Java e invece lo leggi come argomento da riga di comando.

Con il seguente codice,

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

basta andare avanti ed eseguirlo con:

java InputReader < input.txt

Questo leggerebbe il contenuto di input.txte lo stampa sulla tua console.

Puoi anche fare in modo che tu System.out.println()scriva su un file specifico attraverso la riga di comando come segue:

java InputReader < input.txt > output.txt

Questo sarebbe leggere input.txte scrivere a output.txt.


2

Puoi usare readAllLines e il joinmetodo per ottenere l'intero contenuto del file in una riga:

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

Utilizza la codifica UTF-8 per impostazione predefinita, che legge correttamente i dati ASCII.

Inoltre puoi usare readAllBytes:

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

Penso che readAllBytes sia più veloce e più preciso, perché non sostituisce la nuova riga con \ne potrebbe esserlo anche la nuova riga \r\n. Dipende dalle tue esigenze quale è adatto.


1

Per le applicazioni Web Maven basate su JSF, basta usare ClassLoader e la Resourcescartella per leggere qualsiasi file si desideri:

  1. Inserisci qualsiasi file che desideri leggere nella cartella Risorse.
  2. Inserisci la dipendenza IO di Apache Commons nel tuo POM:

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-io</artifactId>
        <version>1.3.2</version>
    </dependency>
  3. Usa il codice qui sotto per leggerlo (ad es. Sotto sta leggendo un file .json):

    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;

Puoi fare lo stesso per file di testo, file .properties, schemi XSD , ecc.


Non puoi usarlo su "qualsiasi file che desideri". Puoi usarlo solo per risorse che sono state impacchettate nel file JAR o WAR.
Marchese di Lorne,

1

Cactoos ti offre una dichiarazione dichiarativa:

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

0

Usa il bacio Java se si tratta della semplicità della struttura:

import static kiss.API.*;

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

0
import java.util.stream.Stream;
import java.nio.file.*;
import java.io.*;

class ReadFile {

 public static void main(String[] args) {

    String filename = "Test.txt";

    try(Stream<String> stream = Files.lines(Paths.get(filename))) {

          stream.forEach(System.out:: println);

    } catch (IOException e) {

        e.printStackTrace();
    }

 }

 }

Usa java 8 Stream.


0
try {
  File f = new File("filename.txt");
  Scanner r = new Scanner(f);  
  while (r.hasNextLine()) {
    String data = r.nextLine();
    JOptionPane.showMessageDialog(data);
  }
  r.close();
} catch (FileNotFoundException ex) {
  JOptionPane.showMessageDialog("Error occurred");
  ex.printStackTrace();
}

0

Il metodo più intuitivo è stato introdotto in Java 11 Files.readString

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String args[]) throws IOException {
        String content = Files.readString(Paths.get("D:\\sandbox\\mvn\\my-app\\my-app.iml"));
        System.out.print(content);
    }
}

PHP ha questo lusso di decenni fa! ☺


-3

Questo codice che ho programmato è molto più veloce per file molto grandi:

public String readDoc(File f) {
    String text = "";
    int read, N = 1024 * 1024;
    char[] buffer = new char[N];

    try {
        FileReader fr = new FileReader(f);
        BufferedReader br = new BufferedReader(fr);

        while(true) {
            read = br.read(buffer, 0, N);
            text += new String(buffer, 0, read);

            if(read < N) {
                break;
            }
        }
    } catch(Exception ex) {
        ex.printStackTrace();
    }

    return text;
}

10
Molto più veloce, ne dubito, se usi una concatenazione di stringhe semplice invece di uno StringBuilder ...
PhiLho,

6
Penso che il guadagno di velocità principale sia dalla lettura in blocchi da 1 MB (1024 * 1024). Tuttavia, puoi fare lo stesso semplicemente passando 1024 * 1024 come secondo argomento al costruttore BufferedReader.
GB

3
non credo che questo sia stato testato affatto. l'uso +=in questo modo ti dà complessità quadratica (!) per un'attività che dovrebbe essere complessità lineare. questo inizierà a eseguire la scansione dei file su alcuni MB. per ovviare a questo problema, dovresti tenere i blocchi di testo in un elenco <stringa> o usare il suddetto stringbuilder.
kritzikratzi,

5
Molto più veloce di cosa? Certamente non è più veloce dell'aggiunta a StringBuffer. -1
Marchese di Lorne,

1
@ gb96 Ho pensato lo stesso delle dimensioni del buffer, ma l'esperimento dettagliato in questa domanda ha dato risultati sorprendenti in un contesto simile: un buffer da 16 KB è stato costantemente e notevolmente più veloce.
chiastic-security

-3
String fileName = 'yourFileFullNameWithPath';
File file = new File(fileName); // Creates a new file object for your file
FileReader fr = new FileReader(file);// Creates a Reader that you can use to read the contents of a file read your file
BufferedReader br = new BufferedReader(fr); //Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

Il set di righe sopra può essere scritto in 1 riga singola come:

BufferedReader br = new BufferedReader(new FileReader("file.txt")); // Optional

Aggiunta al generatore di stringhe (se il file è enorme, si consiglia di utilizzare il generatore di stringhe altrimenti utilizzare il normale oggetto String)

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();
    }
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.