Pregunta Lectura de un archivo de texto plano en Java


Parece que hay diferentes maneras de leer y escribir datos de archivos en Java.

Quiero leer datos ASCII de un archivo. ¿Cuáles son las formas posibles y sus diferencias?


796
2018-01-17 18:29


origen


Respuestas:


ASCII es un archivo de texto, por lo que usaría Lectores para leer. Java también admite la lectura desde un archivo binario usando InputStreams. Si los archivos que se leen son enormes, entonces querrá usar un BufferedReader encima de un FileReader para mejorar el rendimiento de lectura

Atravesar Este artículo sobre cómo usar un lector

También te recomiendo que descargues y leas este maravilloso libro (aún gratuito) llamado Pensando en Java

En Java 7:

nueva cadena (Files.readAllBytes (...)) o Files.readAllLines (...)

En Java 8:

Files.lines (..). ForEach (...)


467
2018-01-17 18:31



Mi forma favorita de leer un archivo pequeño es usar un BufferedReader y un StringBuilder. Es muy simple y directo (aunque no es particularmente efectivo, pero lo suficientemente bueno para la mayoría de los casos):

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

Algunos han señalado que después de Java 7 debes usar try-with-resources (es decir, cierre automático) funciones:

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

Cuando leo cadenas de esta manera, generalmente quiero hacer un manejo de cadenas por línea de todos modos, entonces voy por esta implementación.

Aunque si realmente quiero leer un archivo en una cadena, siempre uso Apache Commons IO con el método de clase IOUtils.toString (). Puedes echar un vistazo a la fuente aquí:

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

Y aún más simple con Java 7:

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

634
2018-01-17 18:42



La forma más fácil es usar el Scanner clase en Java y el objeto FileReader. Ejemplo simple:

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

Scanner tiene varios métodos para leer en cadenas, números, etc. Puede buscar más información sobre esto en la página de documentación de Java.

Por ejemplo, leer todo el contenido en un String:

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

Además, si necesita una codificación específica, puede usar esto en lugar de FileReader:

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

122
2018-01-17 18:35



Aquí hay una solución simple:

String content;

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

59
2018-01-29 16:24



Aquí hay otra forma de hacerlo sin usar bibliotecas externas:

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

54
2018-05-22 21:02



Los métodos dentro org.apache.commons.io.FileUtils también puede ser muy útil, por ejemplo:

/**
 * 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
2018-01-17 18:46



Tuve que comparar las diferentes formas. Voy a comentar sobre mis hallazgos, pero, en resumen, la manera más rápida es usar un BufferedInputStream viejo y simple sobre un FileInputStream. Si se deben leer muchos archivos, tres subprocesos reducirán el tiempo total de ejecución a aproximadamente la mitad, pero agregar más subprocesos degradará progresivamente el rendimiento hasta que tome tres veces más tiempo completarlo con veinte subprocesos que con un solo subproceso.

La suposición es que debe leer un archivo y hacer algo significativo con su contenido. En los ejemplos, aquí está leyendo líneas de un registro y cuenta las que contienen valores que superan un determinado umbral. Así que supongo que el one-liner Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) no es una opinión.

Probé en Java 1.8, Windows 7 y unidades SSD y HDD.

Escribí seis implementaciones diferentes:

rawParse: Utilice BufferedInputStream sobre un FileInputStream y luego corte líneas leyendo byte por byte. Esto superó a cualquier otro enfoque de subproceso único, pero puede ser muy inconveniente para los archivos que no son ASCII.

lineReaderParse: Use un BufferedReader sobre un FileReader, lea línea por línea, líneas separadas llamando a String.split (). Esto es aproximadamente un 20% más lento que RawParse.

lineReaderParseParallel: Esto es lo mismo que lineReaderParse, pero usa varios hilos. Esta es la opción más rápida en general en todos los casos.

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

nioAsyncParse: Use un AsynchronousFileChannel con un controlador de finalización y un grupo de subprocesos.

nioMemoryMappedParse: Utilice un archivo mapeado en memoria. Esta es realmente una mala idea que ofrece tiempos de ejecución al menos tres veces más largos que cualquier otra implementación.

Estos son los tiempos promedio para leer 204 archivos de 4 MB cada uno en una unidad quad-core i7 y SSD. Los archivos se generan sobre la marcha para evitar el almacenamiento en caché 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

Encontré una diferencia más pequeña de lo que esperaba entre correr en una SSD o una unidad de disco duro que era la SSD aproximadamente un 15% más rápida. Esto puede deberse a que los archivos se generan en un disco duro no fragmentado y se leen de forma secuencial, por lo tanto, el disco giratorio puede funcionar casi como un disco SSD.

Me sorprendió el bajo rendimiento de la implementación de nioAsyncParse. O implementé algo de la manera incorrecta o la implementación de múltiples subprocesos utilizando NIO y un controlador de finalización realiza la misma (o incluso peor) que una implementación de subproceso único con la API de java.io. Además, el análisis asíncrono con un CompletionHandler es mucho más largo en líneas de código y es difícil de implementar correctamente que una implementación directa en transmisiones antiguas.

Ahora las seis implementaciones van seguidas de una clase que las contiene a todas más un método principal parametrizable () que permite jugar con el número de archivos, el tamaño del archivo y el grado de simultaneidad. Tenga en cuenta que el tamaño de los archivos varía más menos el 20%. Esto es para evitar cualquier efecto debido a que todos los archivos tienen exactamente el mismo tamaño.

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

IMPLEMENTACIÓN COMPLETA Y RUNIBLE DE TODOS LOS CASOS

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


21
2017-11-14 20:20



Aquí están los tres métodos de trabajo y probados:

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

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

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

Lea el archivo completo sin un bucle con el Scanner clase

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

19
2018-01-10 18:52



¿Qué quieres hacer con el texto? ¿Es el archivo lo suficientemente pequeño como para caber en la memoria? Intentaré encontrar la manera más simple de manejar el archivo para sus necesidades. La biblioteca de FileUtils es muy útil para esto.

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

17
2018-01-17 22:33



A continuación se muestra una línea de hacerlo en el modo Java 8. Asumiendo text.txt el archivo está en la raíz del directorio del proyecto de Eclipse.

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

9
2017-11-15 17:07



Usando 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
2017-12-26 20:17