He estado usando el modismo a continuación por algún tiempo ahora. Y parece ser el más extendido, al menos en los sitios que he visitado.

¿Hay una manera mejor / diferente de leer un archivo en una cadena en Java?

private String readFile(String file) throws IOException {
    BufferedReader reader = new BufferedReader(new FileReader (file));
    String         line = null;
    StringBuilder  stringBuilder = new StringBuilder();
    String         ls = System.getProperty("line.separator");

    try {
        while((line = reader.readLine()) != null) {
            stringBuilder.append(line);
            stringBuilder.append(ls);
        }

        return stringBuilder.toString();
    } finally {
        reader.close();
    }
}

Leer todo el texto de un archivo

Java 11 agregó el método readString () para leer archivos pequeños como Stringterminadores de línea de preservación:

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

Para las versiones entre Java 7 y 11, aquí hay un idioma 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 conveniente para leer un archivo como líneas de texto, representado como a List<String>. Este enfoque es "con pérdida" 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 a Stream<String>. Nuevamente, este método es con pérdida porque los separadores de línea se eliminan. Si IOExceptionse encuentra un mensaje al leer el archivo, se envuelve en un UncheckedIOException, ya Streamque no acepta lambdas que arrojan excepciones marcadas.

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

Esto Streamnecesita una close()llamada; esto está mal documentado en la API, y sospecho que muchas personas ni siquiera notan que Streamtiene 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 el lines()método en su BufferedReaderlugar.

Utilización de la memoria

El primer método, que preserva los saltos de línea, puede requerir temporalmente memoria varias veces el tamaño del archivo, porque por un corto tiempo el contenido del archivo sin formato (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, la lectura de líneas, suele ser más eficiente en la memoria, ya que 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 podría ser de muchos gigabytes de RAM. El tercer método, usar a Stream<String>es una forma de hacerlo, si los "registros" de entrada son líneas individuales. (El uso del readLine()método de BufferedReaderes el equivalente procesal 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 el valor predeterminado de la plataforma es lo que desea, pero son raros y debería poder justificar su elección.

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

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

El valor predeterminado de la plataforma está disponible desde laCharset propia clase :

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, evitó que el archivo que se leía se eliminara hasta que el búfer mapeado se recogiera basura. Puede ver la versión anterior a través del enlace "editado" en esta respuesta.

Si está dispuesto a usar una biblioteca externa, consulte Apache Commons IO (200KB JAR). Contiene un org.apache.commons.io.FileUtils.readFileToString()método que le permite leer un todo Fileen una Stringcon 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 magra 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 bloque de prueba con recursos , que llamará scanner.close()por usted:

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

Recuerde que el Scannerconstructor puede lanzar un IOException. Y no olvides importar java.ioyjava.util .

Fuente: 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 de Commons ), puede usar la clase Escáner :

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

La 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 se debe eliminar 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, consulte las clases Archivos , CharStreams , ByteSource y CharSource en el paquete com.google.common.io .

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 cadena (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 JDK sample/lambda/BulkDataOperationsque se pueden descargar desde la 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 o no ser lo que realmente quieres 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 - COMMONS IO usando las 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 usando Stream API

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

• BufferedReaderutilizando 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 una cadena

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

Tiene el siguiente método

public static String readFileToString(File file) throws IOException

Si quieres las líneas como una lista usa

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

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.fileAPI, que proporciona muchos accesos directos, por lo que las bibliotecas de terceros no siempre son necesarias para las operaciones de archivos simples.

Java intenta ser extremadamente general y flexible en todo lo que hace. Como resultado, algo que es relativamente simple en un lenguaje de script (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 el uso de una biblioteca externa (como mencionó Willi aus Rohr ). Sus opciones:

• Utiliza una biblioteca externa.
• Copie este código en todos sus proyectos.
• Cree su propia mini biblioteca que contenga funciones que utiliza con frecuencia.

Su mejor apuesta es probablemente la segunda, ya que tiene menos dependencias.

Usando JDK 8 o superior:

no se usan bibliotecas externas

Puede crear un nuevo objeto String a partir del contenido del archivo (Usar clases del java.nio.filepaquete):

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

Existe una variación sobre el mismo tema que utiliza 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 a la Filesclase, puede usar 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 StringWriter :

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, cuando se lee desde una URL.

Tenga en cuenta que el uso fileInputStream.available()del número entero devuelto no tiene que representar el tamaño real del archivo, sino la cantidad adivinada de bytes que el sistema debería poder leer de la secuencia sin bloquear las E / S. Una forma segura y simple 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 considerarse que este enfoque no es adecuado para codificaciones de caracteres de varios bytes como UTF-8.

Este usa el método RandomAccessFile.readFully, ¡parece estar disponible desde 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
        }
    }
}

Puedes probar Scanner y File class, 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!");
}

Usuario java.nio.Filespara leer todas las líneas de 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 una nueva línea de caracteres 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 del escáner, creo que la solución del escáner también debería aparecer en la lista. De la manera más fácil de leer, es 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 hacerlo), considere usar try-with-resources para que el código sea más fácil de leer. No más cosas de punto cerrado que ensucian todo. Pero eso es principalmente una elección estilística, creo.

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

Mi sugerencia sería usar Files # readAllBytes (Path) para capturar todos los bytes y alimentarlo a una nueva cadena (byte [] Charset) para obtener una cadena en la que pueda confiar. Los charsets serán malos para ti durante tu vida, así que ten cuidado con estas cosas ahora.

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

Usando esta biblioteca , es una línea:

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

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

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

La ruta debería comenzar, / por ejemplo, si su jarra 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 Reader:

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

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