sobreescribir - Leyendo un archivo de texto plano en Java

mostrar el contenido de un archivo txt en java

Question

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?

Answer 1

¿Qué quieres hacer con el texto? ¿Es el archivo lo suficientemente pequeño como para caber en la memoria? Intentaría 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);

Answer 2

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

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

Answer 3

ASCII es un archivo TEXTO por lo que utilizarías Readers para leer. Java también admite la lectura de un archivo binario utilizando InputStreams . Si los archivos que se están leyendo son enormes, entonces debería usar un BufferedReader sobre un FileReader para mejorar el rendimiento de lectura.

Ir a través de este artículo sobre cómo usar un lector

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

En Java 7 :

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

(docs) o

Files.readAllLines(...)

(docs)

En Java 8 :

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

(docs)

Answer 4

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

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

Lee el archivo completo sin un bucle usando la clase Scanner

package io;

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

public class ReadingEntireFileWithoutLoop {

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

Answer 5

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

Answer 6

Aquí hay una solución simple:

String content;

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

Answer 7

Básicamente, esta es exactamente la misma respuesta de Jesús Ramos, excepto con Archivo en lugar de FileReader más la 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

... lanza la FileNotFoundException

Answer 8

Documenté 15 formas de leer un archivo en Java y luego las probé para la velocidad con varios tamaños de archivo, desde 1 KB hasta 1 GB, y aquí están las tres formas principales de hacer esto:

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

Answer 9

En la práctica, las clases de flujo en búfer tienen mucho más rendimiento, por lo que la API NIO.2 incluye métodos que específicamente devuelven estas clases de flujo, en parte para alentarlo a que siempre use flujos en búfer 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 this artículo para conocer los principales usos de Java NIO y IO.

Answer 10

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 de acceso a su archivo en su código Java y, en cambio, 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);
        }
    }
}

sólo sigue adelante y ejecútalo con:

java InputReader < input.txt

Esto leería el contenido del input.txt y lo imprimiría en la consola.

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

java InputReader < input.txt > output.txt

Esto se leerá desde input.txt y se escribirá en output.txt .

Answer 11

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

Answer 12

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

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

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

Por ejemplo, leyendo todo el contenido en una 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)

Answer 13

La forma más sencilla de leer datos de un archivo en Java es utilizar la clase Archivo para leer el archivo y la clase Escáner 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.

Answer 14

Los métodos dentro de org.apache.commons.io.FileUtils tambié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)

Answer 15

Mi forma favorita de leer un archivo pequeño es usar un BufferedReader y un StringBuilder. Es muy simple y al punto (aunque no es particularmente efectivo, pero es 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 debería usar las funciones de try-with-resources (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, por lo general quiero hacer un poco de manejo de cadenas por línea, así que voy a esta implementación.

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

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

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

Answer 16

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

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

Answer 17

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

1. Ponga cualquier archivo que quiera leer en la carpeta de Recursos.

2. Ponga 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 código a continuación 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.

Answer 18

Probablemente no tan rápido como con E / S con búfer, pero bastante conciso:

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

El patrón /Z le dice al Scanner que el delimitador es EOF.

Answer 19

Puede usar readAllLines y el método de join para obtener el contenido completo 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 preciso, ya que no reemplaza la nueva línea con /n y también la nueva línea puede ser /r/n . Depende de sus necesidades cuál es la adecuada.

Answer 20

Tuve que comparar las diferentes formas. Debo comentar mis hallazgos, pero, en resumen, la forma más rápida es usar un BufferedInputStream antiguo y simple sobre un FileInputStream. Si se deben leer muchos archivos, entonces 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 demore tres veces más en completarse con veinte subprocesos que con un solo subproceso.

El supuesto es que debe leer un archivo y hacer algo significativo con su contenido. En los ejemplos aquí se encuentran las líneas de un registro y se cuentan las que contienen valores que exceden un cierto umbral. Así que Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) una sola línea Java 8 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 de lectura byte a byte. Esto superó cualquier otro enfoque de un solo hilo, 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 divididas llamando String.split (). Esto es aproximadamente un 20% más lento que rawParse.

lineReaderParseParallel : es lo mismo que lineReaderParse, pero usa varios subprocesos. 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 : use un archivo asignado en memoria. Esta es realmente una mala idea que produce 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 i7 y SSD de cuatro núcleos. 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 la ejecución en un SSD o una unidad de disco duro siendo el SSD aproximadamente un 15% más rápido. Esto puede deberse a que los archivos se generan en un disco duro sin fragmentar y se leen de forma secuencial, por lo que la unidad giratoria puede funcionar casi como un SSD.

Me sorprendió el bajo rendimiento de la implementación de nioAsyncParse. 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 un solo hilo con la API java.io. Por otra parte, el análisis asíncrono con un Gestor de finalización es mucho más largo en líneas de código y es difícil de implementar correctamente que una implementación directa en flujos antiguos.

Ahora las seis implementaciones seguidas por 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 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 DE TODOS LOS CASOS

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

Answer 21

Usa el beso de Java 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);
      }
    }
  }
}

Answer 22

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

Answer 23

Cactoos le da un declarativo de una sola línea:

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

Answer 24

Guava proporciona una sola línea para esto:

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

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

Answer 25

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