Leer todo el texto de un archivo

Java 11 agregó el readString () método para leer archivos pequeños como un String, preservando los terminadores de línea:

String content = Files.readString(path, StandardCharsets.US_ASCII);

Para las versiones entre Java 7 y 11, aquí hay un modismo compacto y robusto, envuelto en un método de utilidad:

static String readFile(String path, Charset encoding)
  throws IOException
{
  byte[] encoded = Files.readAllBytes(Paths.get(path));
  return new String(encoded, encoding);
}

Leer líneas de texto de un archivo

Java 7 agregó un método de conveniencia para leer un archivo como líneas de texto, representado como un List<String>. Este enfoque tiene "pérdidas" porque los separadores de línea se eliminan del final de cada línea.

List<String> lines = Files.readAllLines(Paths.get(path), encoding);

Java 8 agregó el Files.lines() método para producir un Stream<String>. Nuevamente, este método tiene pérdidas porque los separadores de línea se eliminan. Si una IOException se encuentra al leer el archivo, está envuelto en un UncheckedIOException, Desde Stream no acepta lambdas que arrojan excepciones marcadas.

try (Stream<String> lines = Files.lines(path, encoding)) {
  lines.forEach(System.out::println);
}

Este Stream necesita un close() llamada; esto está mal documentado en la API, y sospecho que muchas personas ni siquiera se dan cuenta Stream tiene un close() método. Asegúrese de usar un bloque ARM como se muestra.

Si está trabajando con una fuente que no sea un archivo, puede utilizar la lines() método en BufferedReader preferiblemente.

Utilización de la memoria

El primer método, que conserva los saltos de línea, puede requerir temporalmente memoria varias veces el tamaño del archivo, porque durante un corto tiempo el contenido del archivo sin procesar (una matriz de bytes) y los caracteres decodificados (cada uno de los cuales es de 16 bits incluso si está codificado como 8 bits en el archivo) residen en la memoria a la vez. Es más seguro aplicarlo a archivos que sabe que son pequeños en relación con la memoria disponible.

El segundo método, leer líneas, suele ser más eficiente en memoria, porque el búfer de bytes de entrada para la decodificación no necesita contener todo el archivo. Sin embargo, todavía no es adecuado para archivos que son muy grandes en relación con la memoria disponible.

Para leer archivos grandes, necesita un diseño diferente para su programa, uno que lea un fragmento de texto de una secuencia, lo procese y luego pase al siguiente, reutilizando el mismo bloque de memoria de tamaño fijo. Aquí, "grande" depende de las especificaciones de la computadora. Hoy en día, este umbral puede ser de muchos gigabytes de RAM. El tercer método, usando un Stream<String> es una forma de hacer esto, si sus "registros" de entrada resultan ser líneas individuales. (Utilizando la readLine() método de BufferedReader es el procedimiento equivalente a este enfoque).

Codificación de caracteres

Una cosa que falta en la muestra en la publicación original es la codificación de caracteres. Hay algunos casos especiales en los que la plataforma predeterminada es lo que desea, pero son raros y debería poder justificar su elección.

EL StandardCharsets La clase define algunas constantes para las codificaciones requeridas de todos los tiempos de ejecución de Java:

String content = readFile("test.txt", StandardCharsets.UTF_8);

La plataforma predeterminada está disponible en al Charset clase en sí:

String content = readFile("test.txt", Charset.defaultCharset());

Nota: Esta respuesta reemplaza en gran medida mi versión de Java 6. La utilidad de Java 7 simplifica de forma segura el código, y la respuesta anterior, que usaba un búfer de bytes mapeado, impedía que el archivo leído se eliminara hasta que el búfer mapeado fuera recolectado como basura. Puede ver la versión anterior a través del enlace "editado" en esta respuesta.

Si está dispuesto a utilizar una biblioteca externa, consulte Apache Commons E/S (TARRO DE 200 KB). Contiene un org.apache.commons.io.FileUtils.readFileToString() método que le permite leer un File post-extracción String con una línea de código.

Ejemplo:

import java.io.*;
import java.nio.charset.*;
import org.apache.commons.io.*;

public String readFile() throws IOException {
    File file = new File("data.txt");
    return FileUtils.readFileToString(file, StandardCharsets.UTF_8);
}

Una solución muy ajustada basada en Scanner:

Scanner scanner = new Scanner( new File("poem.txt") );
String text = scanner.useDelimiter("\\A").next();
scanner.close(); // Put this call in a finally block

O, si desea configurar el juego de caracteres:

Scanner scanner = new Scanner( new File("poem.txt"), "UTF-8" );
String text = scanner.useDelimiter("\\A").next();
scanner.close(); // Put this call in a finally block

O con un probar con recursos bloque, que llamará scanner.close() para usted:

try (Scanner scanner = new Scanner( new File("poem.txt"), "UTF-8" )) {
    String text = scanner.useDelimiter("\\A").next();
}

Recuerde que los Scanner constructor puede lanzar un IOException. Y no olvides importar java.io y java.util.

Fuente: El blog de Pat Niemeyer

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

String content = new String(Files.readAllBytes(Paths.get("readMe.txt")), StandardCharsets.UTF_8);

desde Java 7 puedes hacerlo de esta manera.

Si está buscando una alternativa que no implique una biblioteca de terceros (p. Ej. E / S comunes), puede utilizar el Escáners clase:

private String readFile(String pathname) throws IOException {

    File file = new File(pathname);
    StringBuilder fileContents = new StringBuilder((int)file.length());        

    try (Scanner scanner = new Scanner(file)) {
        while(scanner.hasNextLine()) {
            fileContents.append(scanner.nextLine() + System.lineSeparator());
        }
        return fileContents.toString();
    }
}

Guayaba tiene un método similar al de Commons IOUtils que Willi aus Rohr mencionó:

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

// ...

String text = Files.toString(new File(path), Charsets.UTF_8);

EDITAR por PiggyPiglet
Files#toString está en desuso y debe eliminarse en Octobor 2019. En su lugar, use Files.asCharSource(new File(path), StandardCharsets.UTF_8).read();

EDITAR por Oscar Reyes

Este es el código subyacente (simplificado) en la biblioteca citada:

InputStream in = new FileInputStream(file);
byte[] b  = new byte[file.length()];
int len = b.length;
int total = 0;

while (total < len) {
  int result = in.read(b, total, len - total);
  if (result == -1) {
    break;
  }
  total += result;
}

return new String( b , Charsets.UTF_8 );

Editar (por Jonik): Lo anterior no coincide con el código fuente de las versiones recientes de Guava. Para la fuente actual, vea las clases archivos, CharStreams, ByteSource y CharSource in com.google.common.io paquete.

import java.nio.file.Files;

.......

 String readFile(String filename) {
            File f = new File(filename);
            try {
                byte[] bytes = Files.readAllBytes(f.toPath());
                return new String(bytes,"UTF-8");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return "";
    }

Si necesita un procesamiento de cadenas (procesamiento paralelo), Java 8 tiene la gran API Stream.

String result = Files.lines(Paths.get("file.txt"))
                    .parallel() // for parallel processing 
                    .map(String::trim) // to change line   
                    .filter(line -> line.length() > 2) // to filter some lines by a predicate                        
                    .collect(Collectors.joining()); // to join lines

Hay más ejemplos disponibles en muestras de JDK sample/lambda/BulkDataOperations que se puede descargar desde Página de descarga de Oracle Java SE 8

Otro ejemplo de un trazador de líneas

String out = String.join("\n", Files.readAllLines(Paths.get("file.txt")));

Ese código normalizará los saltos de línea, que pueden ser o no lo que realmente desea hacer.

Aquí hay una alternativa que no hace eso, y que es (IMO) más simple de entender que el código NIO (aunque todavía usa java.nio.charset.Charset):

public static String readFile(String file, String csName)
            throws IOException {
    Charset cs = Charset.forName(csName);
    return readFile(file, cs);
}

public static String readFile(String file, Charset cs)
            throws IOException {
    // No real need to close the BufferedReader/InputStreamReader
    // as they're only wrapping the stream
    FileInputStream stream = new FileInputStream(file);
    try {
        Reader reader = new BufferedReader(new InputStreamReader(stream, cs));
        StringBuilder builder = new StringBuilder();
        char[] buffer = new char[8192];
        int read;
        while ((read = reader.read(buffer, 0, buffer.length)) > 0) {
            builder.append(buffer, 0, read);
        }
        return builder.toString();
    } finally {
        // Potential issue here: if this throws an IOException,
        // it will mask any others. Normally I'd use a utility
        // method which would log exceptions and swallow them
        stream.close();
    }        
}

Reunió todas las formas posibles de leer el archivo como cadena desde el disco o la red.

• Guayaba: Google usando clases Resources, Files

  static Charset charset = com.google.common.base.Charsets.UTF_8;
  public static String guava_ServerFile( URL url ) throws IOException {
      return Resources.toString( url, charset );
  }
  public static String guava_DiskFile( File file ) throws IOException {
      return Files.toString( file, charset );
  }
  

• APACHE - COMUNES IO usando clases IOUtils, FileUtils

  static Charset encoding = org.apache.commons.io.Charsets.UTF_8;
  public static String commons_IOUtils( URL url ) throws IOException {
      java.io.InputStream in = url.openStream();
      try {
          return IOUtils.toString( in, encoding );
      } finally {
          IOUtils.closeQuietly(in);
      }
  }
  public static String commons_FileUtils( File file ) throws IOException {
      return FileUtils.readFileToString( file, encoding );
      /*List<String> lines = FileUtils.readLines( fileName, encoding );
      return lines.stream().collect( Collectors.joining("\n") );*/
  }
  

• Java 8 BufferReader usar API de transmisión

  public static String streamURL_Buffer( URL url ) throws IOException {
      java.io.InputStream source = url.openStream();
      BufferedReader reader = new BufferedReader( new InputStreamReader( source ) );
      //List<String> lines = reader.lines().collect( Collectors.toList() );
      return reader.lines().collect( Collectors.joining( System.lineSeparator() ) );
  }
  public static String streamFile_Buffer( File file ) throws IOException {
      BufferedReader reader = new BufferedReader( new FileReader( file ) );
      return reader.lines().collect(Collectors.joining(System.lineSeparator()));
  }
  

• Clase de escáner con expresiones regulares \A. que coincide con el comienzo de la entrada.

  static String charsetName = java.nio.charset.StandardCharsets.UTF_8.toString();
  public static String streamURL_Scanner( URL url ) throws IOException {
      java.io.InputStream source = url.openStream();
      Scanner scanner = new Scanner(source, charsetName).useDelimiter("\\A");
      return scanner.hasNext() ? scanner.next() : "";
  }
  public static String streamFile_Scanner( File file ) throws IOException {
      Scanner scanner = new Scanner(file, charsetName).useDelimiter("\\A");
      return scanner.hasNext() ? scanner.next() : "";
  }
  

• Java 7 (java.nio.file.Files.readAllBytes)

  public static String getDiskFile_Java7( File file ) throws IOException {
      byte[] readAllBytes = java.nio.file.Files.readAllBytes(Paths.get( file.getAbsolutePath() ));
      return new String( readAllBytes );
  }
  

• BufferedReader usar InputStreamReader.

  public static String getDiskFile_Lines( File file ) throws IOException {
      StringBuffer text = new StringBuffer();
      FileInputStream fileStream = new FileInputStream( file );
      BufferedReader br = new BufferedReader( new InputStreamReader( fileStream ) );
      for ( String line; (line = br.readLine()) != null; )
          text.append( line + System.lineSeparator() );
      return text.toString();
  }
  

Ejemplo con método principal para acceder a los métodos anteriores.

public static void main(String[] args) throws IOException {
    String fileName = "E:/parametarisation.csv";
    File file = new File( fileName );

    String fileStream = commons_FileUtils( file );
            // guava_DiskFile( file );
            // streamFile_Buffer( file );
            // getDiskFile_Java7( file );
            // getDiskFile_Lines( file );
    System.out.println( " File Over Disk : \n"+ fileStream );


    try {
        String src = "https://code.jquery.com/jquery-3.2.1.js";
        URL url = new URL( src );

        String urlStream = commons_IOUtils( url );
                // guava_ServerFile( url );
                // streamURL_Scanner( url );
                // streamURL_Buffer( url );
        System.out.println( " File Over Network : \n"+ urlStream );
    } catch (MalformedURLException e) {
        e.printStackTrace();
    }
}

@ver

• Formas de convertir un InputStream en un String

Si es un archivo de texto, ¿por qué no usarlo? apache commons-io?

Tiene el siguiente método

public static String readFileToString(File file) throws IOException

Si desea las líneas como una lista, utilice

public static List<String> readLines(File file) throws IOException

Desde JDK 11:

String file = ...
Path path = Paths.get(file);
String content = Files.readString(path);
// Or readString(path, someCharset), if you need a Charset different from UTF-8

Para leer un archivo como binario y convertirlo al final

public static String readFileAsString(String filePath) throws IOException {
    DataInputStream dis = new DataInputStream(new FileInputStream(filePath));
    try {
        long len = new File(filePath).length();
        if (len > Integer.MAX_VALUE) throw new IOException("File "+filePath+" too large, was "+len+" bytes.");
        byte[] bytes = new byte[(int) len];
        dis.readFully(bytes);
        return new String(bytes, "UTF-8");
    } finally {
        dis.close();
    }
}

Java intenta ser extremadamente general y flexible en todo lo que hace. Como resultado, algo que es relativamente simple en un lenguaje de scripting (su código sería reemplazado por "open(file).read()"en Python) es mucho más complicado. No parece haber una forma más corta de hacerlo, excepto usando una biblioteca externa (como Willi aus Rohr mencionado). Sus opciones:

• Utilice una biblioteca externa.
• Copie este código en todos sus proyectos.
• Cree su propia minibiblioteca que contiene las funciones que usa con frecuencia.

Su mejor apuesta es probablemente la segunda, ya que tiene la menor cantidad de dependencias.

Con Java 7, esta es mi opción preferida para leer un archivo UTF-8:

String content = new String(Files.readAllBytes(Paths.get(filename)), "UTF-8");

Desde Java 7, el JDK tiene la nueva java.nio.file API, que proporciona muchos accesos directos, por lo que las bibliotecas de terceros no siempre son necesarias para operaciones de archivos simples.

Utilizando JDK 8 o superior:

no se utilizan bibliotecas externas

Puede crear un nuevo objeto String a partir del contenido del archivo (utilizando clases de java.nio.file paquete):

public String readStringFromFile(String filePath) throws IOException {
    String fileContent = new String(Files.readAllBytes(Paths.get(filePath)));
    return fileContent;
}

Hay una variación en el mismo tema que usa un bucle for, en lugar de un bucle while, para limitar el alcance de la variable de línea. Si es "mejor" es una cuestión de gusto personal.

for(String line = reader.readLine(); line != null; line = reader.readLine()) {
    stringBuilder.append(line);
    stringBuilder.append(ls);
}

Si no tiene acceso al Files class, puede utilizar una solución nativa.

static String readFile(File file, String charset)
        throws IOException
{
    FileInputStream fileInputStream = new FileInputStream(file);
    byte[] buffer = new byte[fileInputStream.available()];
    int length = fileInputStream.read(buffer);
    fileInputStream.close();
    return new String(buffer, 0, length, charset);
}

Una solución flexible que utiliza IOUtils de Apache commons-io en combinación con Escritor de cadenas:

Reader input = new FileReader();
StringWriter output = new StringWriter();
try {
  IOUtils.copy(input, output);
} finally {
  input.close();
}
String fileContents = output.toString();

Funciona con cualquier lector o flujo de entrada (no solo con archivos), por ejemplo, al leer desde una URL.

Tenga cuidado al usar fileInputStream.available() el entero devuelto no tiene que representar el tamaño real del archivo, sino la cantidad estimada de bytes que el sistema debería poder leer de la secuencia sin bloquear la E / S. Una forma segura y sencilla podría verse así

public String readStringFromInputStream(FileInputStream fileInputStream) {
    StringBuffer stringBuffer = new StringBuffer();
    try {
        byte[] buffer;
        while (fileInputStream.available() > 0) {
            buffer = new byte[fileInputStream.available()];
            fileInputStream.read(buffer);
            stringBuffer.append(new String(buffer, "ISO-8859-1"));
        }
    } catch (FileNotFoundException e) {
    } catch (IOException e) { }
    return stringBuffer.toString();
}

Debe tenerse en cuenta que este enfoque es no adecuado para codificaciones de caracteres de varios bytes como UTF-8.

Este usa el método RandomAccessFile.readFully, parece estar disponible en JDK 1.0.

public static String readFileContent(String filename, Charset charset) throws IOException {
    RandomAccessFile raf = null;
    try {
        raf = new RandomAccessFile(filename, "r");
        byte[] buffer = new byte[(int)raf.length()];
        raf.readFully(buffer);
        return new String(buffer, charset);
    } finally {
        closeStream(raf);
    }
} 


private static void closeStream(Closeable c) {
    if (c != null) {
        try {
            c.close();
        } catch (IOException ex) {
            // do nothing
        }
    }
}

Puede probar la clase Scanner and File, una solución de pocas líneas

 try
{
  String content = new Scanner(new File("file.txt")).useDelimiter("\\Z").next();
  System.out.println(content);
}
catch(FileNotFoundException e)
{
  System.out.println("not found!");
}

Según la respuesta de @ erickson, puede usar:

public String readAll(String fileName) throws IOException {
    List<String> lines = Files.readAllLines(new File(fileName).toPath());
    return String.join("\n", lines.toArray(new String[lines.size()]));
}

Usuario java.nio.Files para leer todas las líneas del archivo.

public String readFile() throws IOException {
        File fileToRead = new File("file path");
        List<String> fileLines = Files.readAllLines(fileToRead.toPath());
        return StringUtils.join(fileLines, StringUtils.EMPTY);
}

public static String slurp (final File file)
throws IOException {
    StringBuilder result = new StringBuilder();

    BufferedReader reader = new BufferedReader(new FileReader(file));

    try {
        char[] buf = new char[1024];

        int r = 0;

        while ((r = reader.read(buf)) != -1) {
            result.append(buf, 0, r);
        }
    }
    finally {
        reader.close();
    }

    return result.toString();
}

Todavía no puedo comentar otras entradas, así que lo dejaré aquí.

Una de las mejores respuestas aquí (https://stackoverflow.com/a/326448/1521167):

private String readFile(String pathname) throws IOException {

File file = new File(pathname);
StringBuilder fileContents = new StringBuilder((int)file.length());
Scanner scanner = new Scanner(file);
String lineSeparator = System.getProperty("line.separator");

try {
    while(scanner.hasNextLine()) {        
        fileContents.append(scanner.nextLine() + lineSeparator);
    }
    return fileContents.toString();
} finally {
    scanner.close();
}
}

todavía tiene un defecto. Siempre pone un nuevo carácter de línea al final de la cadena, lo que puede causar algunos errores extraños. Mi sugerencia es cambiarlo a:

    private String readFile(String pathname) throws IOException {
    File file = new File(pathname);
    StringBuilder fileContents = new StringBuilder((int) file.length());
    Scanner scanner = new Scanner(new BufferedReader(new FileReader(file)));
    String lineSeparator = System.getProperty("line.separator");

    try {
        if (scanner.hasNextLine()) {
            fileContents.append(scanner.nextLine());
        }
        while (scanner.hasNextLine()) {
            fileContents.append(lineSeparator + scanner.nextLine());
        }
        return fileContents.toString();
    } finally {
        scanner.close();
    }
}

Después de Ctrl + F'ing después de Scanner, creo que la solución Scanner también debería aparecer en la lista. De la manera más fácil de leer, dice así:

public String fileToString(File file, Charset charset) {
  Scanner fileReader = new Scanner(file, charset);
  fileReader.useDelimiter("\\Z"); // \Z means EOF.
  String out = fileReader.next();
  fileReader.close();
  return out;
}

Si usa Java 7 o más reciente (y realmente debería) considere usar try-with-resources para que el código sea más fácil de leer. No más cosas con puntos de cierre ensuciando todo. Pero esa es principalmente una elección estilística, me parece.

Estoy publicando esto principalmente para completar, ya que si necesita hacer esto mucho, debería haber cosas en java.nio.file.Archivos eso debería hacer mejor el trabajo.

Mi sugerencia sería utilizar Archivos # readAllBytes (ruta) para tomar todos los bytes y alimentarlos a nuevos Cadena (byte [] conjunto de caracteres) para obtener una cadena en la que puedas confiar. Los conjuntos de caracteres serán malos contigo durante tu vida, así que ten cuidado con esto ahora.

Otros han dado código y esas cosas, y no quiero robarles su gloria. ;)

Usar esta biblioteca, es una línea:

String data = IO.from(new File("data.txt")).toString();

Además, si su archivo está dentro de un frasco, también puede usar esto:

public String fromFileInJar(String path) {
    try ( Scanner scanner 
            = new Scanner(getClass().getResourceAsStream(path))) {
        return scanner.useDelimiter("\\A").next();
    }
}

El camino debe comenzar con / por ejemplo, si tu frasco es

my.jar/com/some/thing/a.txt

Entonces quieres invocarlo así:

String myTxt = fromFileInJar("/com/com/thing/a.txt");

En una línea (Java 8), suponiendo que tenga un lector:

String sMessage = String.join("\n", reader.lines().collect(Collectors.toList()));