¿Cómo creo una cadena Java a partir del contenido de un archivo?

He estado usando el siguiente modismo durante algún tiempo. Y parece ser el más extendido, al menos en los sitios que he visitado.

¿Existe una forma 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();
    }
}

preguntado el 28 de noviembre de 08 a las 16:11

¿Alguien puede explicarme de una manera muy sencilla qué pasa con el NIO? Cada vez que leo sobre él, me pierdo en la enésima mención del canal :( -

recuerde que no se garantiza que el separador de línea en el archivo no sea necesario al igual que el separador de línea del sistema. -

¿Podría insertar un intento adecuado finalmente que cierre el lector? Alguien podría usar este ejemplo e introducir un error en su código. -

El código anterior tiene un error de agregar caracteres de línea nuevos adicionales en la última línea. Debería ser algo como seguir if (línea = reader.readLine ())! = Null) {stringBuilder.append (line); } while (línea = reader.readLine ())! = null) {stringBuilder.append (ls); stringBuilder.append (línea); } -

Presenta Java 7 byte[] Files.readAllBytes(file); Para aquellos que sugieren la solución de escáner de 'una línea': ¿No es necesario que lo cierren? -

30 Respuestas

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 planteamiento de « 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.

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

Respondido el 28 de Septiembre de 20 a las 16:09

Técnicamente hablando, es O (n) en el tiempo y el espacio. Cualitativamente, debido al requisito de inmutabilidad de Strings, es bastante difícil para la memoria; temporalmente hay dos copias de los datos de caracteres en la memoria, más el espacio para los bytes codificados. Suponiendo alguna codificación de un solo byte, requerirá (temporalmente) 5 bytes de memoria para cada carácter en el archivo. Dado que la pregunta pide específicamente una cadena, eso es lo que muestro, pero si puede trabajar con el CharBuffer devuelto por "decodificar", el requisito de memoria es mucho menor. En cuanto al tiempo, no creo que encuentre nada más rápido en las librerías principales de Java. - erickson

¿Posible error tipográfico? NIO tiene una clase Charset (no CharSet) llamada java.nio.charset.Charset. ¿Es esto lo que debería haber sido CharSet? - Jonathan Wright

Nota: después de ejercitar un poco ese código, descubrí que no se puede eliminar de manera confiable el archivo inmediatamente después de leerlo con este método, lo que puede no ser un problema en algunos casos, pero no el mío. Que sea en relación con este tema: bugs.sun.com/bugdatabase/view_bug.do?bug_id=4715154 ? Finalmente fui con la propuesta de Jon Skeet que no sufre de este error. De todos modos, solo quería dar la información, para otras personas, por si acaso ... - Sébastien Nussbaumer

@ Sébastien Nussbaumer: También me topé con este problema. Es sorprendente que el error haya sido marcado como "No se arreglará". Esto esencialmente significa que FileChannel#map es, en general, inutilizable. - Joonas Pulakka

@ Sébastien Nussbaumer: El error se ha eliminado de la base de datos de Oracle / Sun Bug: "Este error no está disponible". Google almacenó en caché el sitio en webcache.googleusercontent.com/search?q=cache:bugs.sun.com/… - bobandrew

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

Respondido 27 Abr '19, 06:04

No encuentro ese método en la URL que proporcionas. - oscarryz

Está en la clase org.apache.commons.io.FileUtils - cirille ka

También estoy usando FileUtils, pero me pregunto qué es mejor entre usar FileUtils o la respuesta nio aceptada. - William

@Guillaume: La pregunta más importante es si se siente cómodo al depender de una biblioteca de terceros. Si tiene Commons IO o Guayaba en su proyecto, luego utilícelo (solo para simplificar el código; de lo contrario, es probable que no haya una diferencia notable). - Jonik

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

Respondido 27 Abr '19, 07:04

\\ A funciona porque no hay "otro comienzo de archivo", por lo que de hecho está leyendo el último token ... que también es el primero. Nunca probé con \\ Z. También tenga en cuenta que puede leer cualquier cosa que sea legible, como archivos, flujos de entrada, canales ... A veces uso este código para leer desde la ventana de visualización de eclipse, cuando no estoy seguro de si estoy leyendo un archivo u otro. .sí, classpath me confunde. - pablo grisafi

Como póster, puedo decir que realmente no sé si el archivo está bien cerrado y cuándo ... Nunca escribo este en código de producción, lo uso solo para pruebas o depuración. - pablo grisafi

Tiene un límite de 1024 caracteres, creo. Caprichoso

Scanner implementa Closeable (invoca close en la fuente), por lo que, si bien es elegante, no debería ser una frase única. El tamaño predeterminado del búfer es 1024, pero Scanner aumentará el tamaño según sea necesario (consulte Scanner # makeSpace ()) - cámara auditiva

Este falla para archivos vacíos con un java.util.NoSuchElementException. - camionero espacial

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.

Respondido el 23 de enero de 20 a las 01:01

Esto debe aceptarse como respuesta: una sola línea, sin bibliotecas externas. - De cereza

Esto agregó un carácter de nueva línea al final, incluso si no estaba presente en el archivo: Stefan Haberl

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

Respondido 25 Oct 18, 15:10

Creo que esta es la mejor forma. Verificar java.sun.com/docs/books/tutorial/essential/io/scanning.html - Tarski

El constructor del escáner que acepta una cadena no trata la cadena como el nombre de un archivo para leer, sino como el texto a escanear. Cometo ese error todo el tiempo. : - / - Alan Moore

@ Alan, buen partido. Edité ligeramente la respuesta de Don para arreglar eso (espero). - Jonik

fileContents.append (scanner.nextLine ()). append (lineSeparator); - prohibición de la geoingeniería

Cambie la instrucción de inicialización a Scanner scanner = new Scanner((Readable) new BufferedReader(new FileReader(file)));. De lo contrario, solo puede capturar una parte del archivo. - wei yang

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.

respondido 17 nov., 19:10

Este código tiene conversión de long a int, lo que podría mostrar un comportamiento loco con archivos grandes. ¿Tiene espacios adicionales y dónde cierra el flujo de entrada? - Mohamed Taher Alrefaie

@MTA: La corriente is cerrado, tenga en cuenta el uso de Closer in CharSource. El código de la respuesta no es la fuente actual de Guava. - Jonik

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

Respondido 16 Abr '12, 15:04

O incluso más simple: new String(Files.readAllBytes(FileSystems.getDefault().getPath( filename))); - usuario321068

or new String(Files.readAllBytes(Paths.get(filename))); :-)- asafmo

Bien jugado, y para salvar al próximo chico, el Google, Paths aparentemente es 1.7+ como es FileSystems. (¡Maldita sea!) - ruffin

Es una pena que esta respuesta no tenga más votos. Estaba buscando la forma más rápida y sencilla de convertir un archivo de texto en una cadena. Esto es todo y si no me hubiera desplazado hacia abajo y hacia abajo y hacia abajo, me lo habría perdido. El OP debería considerar aceptar esta respuesta para moverla a la cima. - espina

@Thorn Esta respuesta tiene un manejo de errores horrible. No use este método en el código de producción, o mejor: nunca. - xehpuk

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

Respondido el 02 de Septiembre de 16 a las 12:09

¿El .parallel () ocurre después de leer las líneas o antes de eso? - Istvan

El trabajo real comienza desde que se invoca la operación de terminal collect (...). Stream se llena de forma perezosa línea a línea. No es necesario leer todo el archivo en la memoria antes de procesarlo (por ejemplo, filtrado y mapeo). - Andrei N.

recortar antes de elegir líneas no vacías? - Thorbjorn Ravn Andersen

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

Respondido el 26 de Septiembre de 17 a las 05:09

Perdóname por revivir un comentario tan antiguo, pero ¿pretendías pasar un objeto String llamado "archivo", o debería ser un objeto File en su lugar? - Bryan Larson

Gran respuesta. +1. Pero esta respuesta tiene 12 años. Java ahora tiene try-with-resources. - Harshal Parek

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

Respondido 17 ago 18, 07:08

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

Respondido el 26 de Septiembre de 17 a las 05:09

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

Respondido el 26 de junio de 18 a las 15:06

¿Por qué, oh por qué, introducir nuevos métodos que se basan en el juego de caracteres predeterminado en 2018? - mryan

@mryan este método no se basa en el juego de caracteres predeterminado del sistema. Por defecto es UTF-8, eso está bien. - leventov

@leventov, ¡tienes razón! ¡también Files.readAllLines! eso hace que la API de archivos no sea muy consistente con los métodos anteriores, pero es para mejor :) - mryan

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

Respondido 18 Abr '10, 08:04

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.

contestado el 23 de mayo de 17 a las 12:05

Yeap. Hace que el lenguaje de nivel "alto" tenga un significado diferente. Java es de alto nivel en comparación con C pero bajo en comparación con Python o Ruby - oscarryz

De acuerdo en que Java es largo en abstracciones de alto nivel pero corto en métodos de conveniencia - Donal

Es cierto que Java tiene una cantidad increíble de formas de manejar archivos y muchas de ellas parecen complicadas. Pero esto se acerca bastante a lo que tenemos en lenguajes de nivel superior: byte[] bytes = Files.readAllBytes(someFile.toPath()); - espina

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.

contestado el 06 de mayo de 16 a las 10:05

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

Respondido 18 Jul 18, 18:07

Duplicado de la respuesta de Moritz Petersen que escribió: String content = new String (Files.readAllBytes (Paths.get (nombre de archivo)), "UTF-8"); - Jean-Christophe Blanchard

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

Respondido 01 ago 13, 21:08

Esto cambiará las líneas nuevas a la opción de línea nueva predeterminada. Esto puede ser deseable o involuntario. - pedro laurey

Revirtió la edición a esta respuesta porque el punto era reducir el alcance de la line variable. La edición lo declaró dos veces, lo que sería un error de compilación. - Dan Dyer

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

respondido 13 nov., 18:12

ejemplo de juego de caracteres para invocar? - Thufir

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.

Respondido el 01 de diciembre de 16 a las 15:12

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.

respondido 15 mar '13, 09:03

Este código puede dar resultados impredecibles. De acuerdo con la documentación de los available() método, no hay garantía de que se alcance el final del archivo en caso de que el método devuelva 0. En ese caso, podría terminar con un archivo incompleto. Lo que es peor, el número de bytes realmente leídos puede ser menor que el valor devuelto por available(), en cuyo caso la salida se corrompe. - wau

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

Respondido 07 Feb 14, 12:02

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

Respondido 07 Feb 17, 06:02

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

contestado el 10 de mayo de 18 a las 11:05

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

Respondido 26 Oct 18, 07:10

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

respondido 13 nov., 18:18

Creo que esto tiene el inconveniente de usar la codificación predeterminada de la plataforma. +1 de todos modos :) - oscarryz

Me parece que el bloque finalmente no conoce las variables definidas en el bloque try. javac 1.6.0_21 arroja el error cannot find symbol. - ceving

¿Has probado tu propio código? Ha definido el lector en el bloque try / catch, por lo que no será accesible en el bloque finalmente. - mauro85

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

contestado el 23 de mayo de 17 a las 13:05

En el primer caso, es posible que esté agregando una nueva línea adicional al final. en el segundo caso, podría estar omitiendo uno. Entonces ambos están igualmente equivocados. Ver este artículo - Patricio Parker

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

respondido 29 nov., 15:14

Usar esta biblioteca, es una línea:

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

Respondido el 10 de diciembre de 16 a las 15:12

si no se cuentan las líneas dentro de la biblioteca. - Ari

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

Respondido 15 Feb 17, 21:02

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

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

respondido 15 mar '17, 02:03

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.