Leer un archivo de texto plano en Java


933

Parece que hay diferentes formas 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?


24
También estoy en desacuerdo con el cierre como "no constructivo". Afortunadamente, esto bien podría cerrarse como duplicado . Buenas respuestas, por ejemplo, en ¿Cómo crear una cadena a partir del contenido de un archivo? , ¿Cuál es la forma más sencilla de leer un archivo en String? , ¿Cuáles son las clases más simples para leer archivos?
Jonik

Sin bucles: {{{Scanner sc = nuevo escáner (archivo, "UTF-8"); sc.useDelimiter ("$ ^"); // expresiones regulares que no coinciden con nada String text = sc.next (); sc.close (); }}}
Aivar

3
es tan interesante que no hay nada como "read ()" en python, para leer todo el archivo en una cadena
kommradHomer

2
Esta es la forma más sencilla de hacer esto: mkyong.com/java/…
dellasavia

Respuestas:


567

ASCII es un archivo de TEXTO que usaría Readerspara leer. Java también admite la lectura de un archivo binario usando InputStreams. Si los archivos que se leen son enormes, entonces querrá usar BufferedReaderuna FileReaderpara mejorar el rendimiento de lectura.

Lee este artículo sobre cómo usar unReader

También te recomiendo que descargues y leas este libro maravilloso (pero gratuito) llamado Pensamiento en Java

En Java 7 :

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

(docs) o

Files.readAllLines(...)

(documentos)

En Java 8 :

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

(documentos)


14
Elegir un lector realmente depende de para qué necesita el contenido del archivo. Si el archivo es pequeño (ish) y lo necesita todo, es más rápido (evaluado por nosotros: 1.8-2x) simplemente usar un FileReader y leer todo (o al menos fragmentos lo suficientemente grandes). Si lo está procesando línea por línea, vaya al BufferedReader.
Vlad

3
¿Se conservará el orden de las líneas al usar "Files.lines (..). ForEach (...)"? Tengo entendido que la orden será arbitraria después de esta operación.
Daniil Shevelev

39
Files.lines(…).forEach(…)no conserva el orden de las líneas pero se ejecuta en paralelo, @Dash. Si el pedido es importante, puede usarlo Files.lines(…).forEachOrdered(…), lo que debería preservar el pedido (aunque no se verificó).
Palec

2
@Palec esto es interesante, pero ¿puedes citar los documentos donde dice que Files.lines(...).forEach(...)se ejecuta en paralelo? Pensé que este era solo el caso cuando explícitamente haces que la secuencia sea paralela usando Files.lines(...).parallel().forEach(...).
Klitos Kyriacou

3
Mi formulación original no es a prueba de balas, @KlitosKyriacou. El punto es que forEachno garantiza ningún orden y la razón es la paralelización fácil. Si se debe preservar el orden, úselo forEachOrdered.
Palec

687

Mi forma favorita de leer un archivo pequeño es usar un BufferedReader y un StringBuilder. Es muy simple y al grano (aunque no 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 debe usar las funciones de prueba con recursos (es decir, cierre automático):

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 como esta, generalmente quiero hacer un poco de manejo de cadenas por línea de todos modos, así que voy por esta implementación.

Aunque si en realidad solo 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();
}

E incluso más simple con Java 7:

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

66
He hecho un pequeño ajuste para dejar de agregar una nueva línea (\ n) si se llega a la última línea. code while (line! = null) {sb.append (line); línea = br.readLine (); // Solo agregue una nueva línea cuando curline NO sea la última línea ... if (line! = Null) {sb.append ("\ n"); }}code
Ramon Fincken

2
Similar a Apache Common IO IOUtils # toString () es sun.misc.IOUtils # readFully (), que está incluido en los JRE de Sun / Oracle.
gb96

3
Para el rendimiento, siempre llame a sb.append ('\ n') con preferencia a sb.append ("\ n") ya que un carácter se agrega al StringBuilder más rápido que un String
gb96

2
FileReader puede lanzar FileNotFoundException y BufferedRead puede lanzar IOException, por lo que debe atraparlos.
kamaci

44
no hay necesidad de usar lectores directamente ni tampoco de ioutils. java7 ha incorporado métodos para leer un archivo completo / todas las líneas: consulte docs.oracle.com/javase/7/docs/api/java/nio/file/… y docs.oracle.com/javase/7/docs/api / java / nio / file / ...
kritzikratzi

142

La forma más fácil es usar la Scannerclase 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)

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

16
@Hissain Pero mucho más fácil de usar queBufferedReader
Jesus Ramos

3
Debe rodearlo con try Catch
Rahal Kanishka

@JesusRamos No realmente, ¿por qué piensas eso? ¿Qué es más fácil sobre esto que while ((line = br.readLine()) != null) { sb.append(line); }?
Marqués de Lorne

83

Aquí hay una solución simple:

String content;

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

2
@Nery Jr, elegante y simple
Mahmoud Saleh

1
Lo mejor y lo más simple.
Dary

57

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

10
o use "try-with-resources" try (FileReader reader = new FileReader (file))
Hernán Eche

3
Noté el file.length (), ¿Qué tan bien funciona esto con los archivos utf-16?
Wayne

55
Esta técnica supone que read () llena el búfer; que el número de caracteres es igual al número de bytes; que el número de bytes cabe en la memoria; y que el número de bytes se ajusta a un número entero. -1
Marqués de Lorne

1
@HermesTrismegistus Proporcioné cuatro razones por las cuales está mal. StefanReich tiene toda la razón de estar de acuerdo conmigo.
Marqués de Lorne

35

Tuve que comparar las diferentes formas. Comentaré mis hallazgos pero, en resumen, la forma más rápida es usar un viejo BufferedInputStream 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 la adición de más subprocesos degradará progresivamente el rendimiento hasta que se tarde tres veces más en completar 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 exceden un cierto umbral. Así que supongo que el Java 8 de una sola línea Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))no es una opción.

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

Escribí seis implementaciones diferentes:

rawParse : use BufferedInputStream sobre un FileInputStream y luego corte las 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, divida las líneas llamando a String.split (). Esto es aproximadamente un 20% más lento que rawParse.

lineReaderParseParallel : es lo mismo que lineReaderParse, pero utiliza 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 : utilice un AsynchronousFileChannel con un controlador de finalización y un grupo de subprocesos.

nioMemoryMappedParse : use un archivo mapeado en memoria. Esta es realmente una mala idea que genera 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 un i7 de cuatro núcleos y una unidad 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 un SSD o un disco duro, ya que el SSD es aproximadamente un 15% más rápido. Esto puede deberse a que los archivos se generan en un HDD no fragmentado y se leen secuencialmente, por lo tanto, la unidad giratoria puede funcionar casi como un SSD.

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

Ahora las seis implementaciones seguidas de una clase que las contiene todas más un método main () parametrizable que permite jugar con la cantidad de archivos, el tamaño del archivo y el grado de concurrencia. Tenga en cuenta que el tamaño de los archivos varía más menos 20%. Esto es para evitar cualquier efecto debido a que todos los archivos son exactamente del 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 EJECUTABLE COMPLETA DE TODOS LOS CASOS

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


24

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 todo el archivo sin bucle usando la Scannerclase

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
¿Cómo dar ruta si las carpetas están presentes dentro del proyecto?
Kavipriya

2
¿Qué hay de java.nio.file.Files? Podemos ahora sólo tiene que utilizar readAllLines, readAllBytesy lines.
Claude Martin

21

Los métodos dentro org.apache.commons.io.FileUtilstambién pueden ser muy útiles, 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)

O si prefiere Guava (una biblioteca más moderna y mantenida activamente), tiene utilidades similares en su clase de Archivos . Ejemplos simples en esta respuesta .
Jonik

1
o simplemente usa el método incorporado para obtener todas las líneas: docs.oracle.com/javase/7/docs/api/java/nio/file/…
kritzikratzi

El enlace en apache commons parece muerto.
kebs

17

¿Qué quieres hacer con el texto? ¿El archivo es lo suficientemente pequeño como para caber en la memoria? Trataría de encontrar la forma más sencilla de manejar el archivo según sus necesidades. La biblioteca FileUtils es muy manejable para esto.

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


@PeterLawrey probablemente significa org.apache.commons.io.FileUtils. El enlace de Google puede cambiar el contenido con el tiempo, a medida que cambia el significado más extendido, pero esto coincide con su consulta y parece correcto.
Palec

2
Desafortunadamente, hoy en día no existe readLines(String)y readLines(File)está en desuso a favor readLines(File, Charset). La codificación se puede suministrar también como una cadena.
Palec


12

Documenté 15 formas de leer un archivo en Java y luego probé su velocidad con varios tamaños de archivo, desde 1 KB a 1 GB, y estas son las tres formas principales de hacerlo:

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

    Probado para trabajar en Java 7, 8 y 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()

    Probado para trabajar en 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()

    Esto se probó para funcionar en Java 8 y 9, pero no funcionará en Java 7 debido al requisito de expresión 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

A continuación se muestra un resumen de cómo hacerlo en la forma Java 8. Suponiendo que el text.txtarchivo está en la raíz del directorio del proyecto de Eclipse.

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

7

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

Esto es básicamente exactamente lo mismo que la respuesta de Jesús Ramos, excepto con File en lugar de FileReader más iteración para recorrer el contenido del archivo.

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

... tira FileNotFoundException


3
File vs FileReader: con un FileReader, el archivo debe existir y los permisos del sistema operativo deben permitir el acceso. Con un archivo, es posible probar esos permisos o verificar si el archivo es un directorio. El archivo tiene funciones útiles: isFile (), isDirectory (), listFiles (), canExecute (), canRead (), canWrite (), exist (), mkdir (), delete (). File.createTempFile () escribe en el directorio temporal predeterminado del sistema. Este método devolverá un objeto de archivo que se puede utilizar para abrir objetos FileOutputStream, etc. fuente
ThisClark

7

Las clases de secuencias almacenadas en búfer son mucho más eficaces en la práctica, tanto que la API NIO.2 incluye métodos que devuelven específicamente estas clases de secuencias, en parte para alentarlo a que use siempre secuencias almacenadas en su aplicación.

Aquí hay un ejemplo:

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

Puedes reemplazar este código

BufferedReader reader = Files.newBufferedReader(path);

con

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

Recomiendo este artículo para conocer los principales usos de Java NIO e IO.


6

Probablemente no sea tan rápido como con las E / S almacenadas, pero es bastante breve:

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

El \Zpatrón indica Scannerque el delimitador es EOF.


1
Una respuesta muy relacionada, ya existente, es de Jesús Ramos.
Palec

1
Es cierto, debería ser: if(scanner.hasNext()) content = scanner.next();
David Soroko

1
Esto me falla en Android 4.4. Solo se leen 1024 bytes. YMMV.
Roger Keays

3

Aún no lo veo mencionado en las otras respuestas hasta ahora. Pero si "Mejor" significa velocidad, entonces la nueva E / S Java (NIO) podría proporcionar el rendimiento más rápido, pero no siempre es el más fácil de descubrir para alguien que está aprendiendo.

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


Deberías haber dicho cómo se hace y no dar un enlace para seguir
Orar

3

La forma más sencilla de leer datos de un archivo en Java es utilizar la clase File para leer el archivo y la clase Scanner para leer el contenido del archivo.

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

PD: No olvides importar java.util. *; para que el escáner funcione.


2

La guayaba ofrece una frase para esto:

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

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

2

Esta podría no ser la respuesta exacta a la pregunta. Es solo otra forma de leer un archivo en el que no especifica explícitamente la ruta a su archivo en su código Java y, en su lugar, lo lee como un argumento de línea de comandos.

Con el siguiente código,

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

simplemente adelante y ejecútalo con:

java InputReader < input.txt

Esto leería el contenido de la input.txte imprimiría en su consola.

También puede hacer System.out.println()que escriba en un archivo específico a través de la línea de comando de la siguiente manera:

java InputReader < input.txt > output.txt

Esto leería input.txty escribiría a output.txt.


2

Puede usar readAllLines y el joinmétodo para obtener todo el contenido del archivo en una línea:

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

Utiliza la codificación UTF-8 de forma predeterminada, que lee los datos ASCII correctamente.

También puedes usar readAllBytes:

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

Creo que readAllBytes es más rápido y más preciso, porque no reemplaza una nueva línea \ny también puede ser una nueva línea \r\n. Dependiendo de sus necesidades, cuál es el adecuado.


1

Para las aplicaciones web Maven basadas en JSF, solo use ClassLoader y la Resourcescarpeta para leer el archivo que desee:

  1. Ponga cualquier archivo que desee leer en la carpeta Recursos.
  2. Coloque la dependencia de Apache Commons IO en su POM:

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-io</artifactId>
        <version>1.3.2</version>
    </dependency>
  3. Use el siguiente código para leerlo (por ejemplo, a continuación se lee en un archivo .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;

Puede hacer lo mismo para archivos de texto, archivos .properties, esquemas XSD , etc.


No puede usar esto en 'cualquier archivo que desee'. Solo puede usarlo para recursos que se han empaquetado en el archivo JAR o WAR.
Marqués de Lorne


0

Use Java kiss si se trata de simplicidad de estructura:

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

 }

 }

Solo 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

El método más intuitivo se introduce en 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 tiene este lujo de hace décadas! ☺


-3

Este código que programé es mucho más rápido para archivos muy grandes:

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
Mucho más rápido, lo dudo, si utiliza sencilla concatenación de cadenas en lugar de un StringBuilder ...
PhiLho

66
Creo que la ganancia de velocidad principal es de la lectura en bloques de 1 MB (1024 * 1024). Sin embargo, podría hacer lo mismo simplemente pasando 1024 * 1024 como segundo argumento al constructor BufferedReader.
gb96

3
No creo que esto se pruebe en absoluto. el uso +=de esta manera le brinda complejidad cuadrática (!) para una tarea que debería ser una complejidad lineal. esto comenzará a rastrear archivos de más de unos pocos mb. para evitar esto, debe mantener los bloques de texto en una lista <cadena> o usar el generador de cadenas antes mencionado.
kritzikratzi

55
¿Mucho más rápido que qué? Sin duda, no es más rápido que agregar un StringBuffer. -1
Marqués de Lorne

1
@ gb96 Pensé lo mismo sobre los tamaños de búfer, pero el experimento detallado en esta pregunta dio resultados sorprendentes en un contexto similar: un búfer de 16 KB fue consistente y notablemente más rápido.
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.

El conjunto de líneas anterior se puede escribir en 1 sola línea como:

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

Agregar al generador de cadenas (si el archivo es enorme, se recomienda usar el generador de cadenas; de lo contrario, use el objeto de cadena normal)

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();
    }
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.