Leer un archivo de texto plano en Java

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?

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)

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
}

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)

Aquí hay una solución simple:

String content;

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

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

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

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

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)

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

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

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

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

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

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.

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.

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

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.

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

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.

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.

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.

Cactoos te ofrece una frase declarativa:

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

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

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.

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

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! ☺

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

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