¿Cómo puedo crear un Java de la cadena desde el contenido de un archivo?

He estado usando el lenguaje de abajo durante algún tiempo ahora. Y parece ser la más extendida, al menos en los sitios que he visitado.

Hay mejor/forma 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();
    }
}
  • ¿Alguien puede explicar a mí de una manera muy sencilla ¿qué pasa con el NIÑO? Cada vez que leo acerca de itI perderse en el enésimo mención de canal 🙁
  • recuerde que no está garantizado que el separador de línea en el archivo no es necesario el mismo que el del sistema separador de línea.
  • Podría usted por favor, inserte un adecuado tratar, finalmente, que cierra el lector? Alguien en realidad podría utilizar este ejemplo, y a introducir un error en su código.
  • Código anterior tiene un error de la adición de la nueva línea de char en la última línea. Debe ser algo como la siguiente si(línea = lector.readLine() ) != null){ stringBuilder.append( linea ); } while (linea = lector.readLine() ) != null) { stringBuilder.append( ls ); stringBuilder.append( linea ); }
  • Java 7 presenta byte[] Files.readAllBytes(file); A aquellos, que sugieren la «línea» de la solución de Escáner: no yo necesito para cerrarla?
  • El cambio más grande para mí es que NIO le permite escuchar a muchos puertos sin la asignación de un hilo para cada uno. No es un problema a menos que usted desea enviar un paquete a cada máquina en una red de clase B de espacio de direcciones (65k direcciones) para ver lo que existe, Windows se ejecuta fuera de los hilos en alrededor de 20k (que se Encuentra esta fuera de problemas exactamente este problema–el descubrimiento de una clase A/B de la red, antes de NIO era difícil).
  • Si usted ve los Archivos.readAllBytes() aplicación, usted se dará cuenta de que está utilizando un canal que es closeable. Así que no hay necesidad de cerrar de forma explícita.
  • Con el advenimiento de Groovy, usted puede leer el archivo así: return new File( archivo).texto()
  • La vinculación de otro StackOverflow enlace, que se encuentra está muy bien explicado: stackoverflow.com/questions/14169661/…
  • La última línea en un archivo de texto es por lo general la línea de terminación, de modo que lo que usted describe como un error no es uno, y su código tiene el bug de la eliminación de todos los terminadores de línea.

InformationsquelleAutor OscarRyz | 2008-11-28

32 Kommentare

  1. 1472

    Leer todo el texto de un archivo

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

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

    Para las versiones entre Java 7 y 11, aquí es compacto, robusto lenguaje, 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 conveniencia método para leer un archivo como líneas de texto, representado como un List<String>. Este enfoque es el de «pérdida» porque los separadores de línea se eliminan desde el final de cada línea.

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

    Java 8, agregó el Archivos.líneas() método para producir un Stream<String>. De nuevo, este método tiene pérdida porque separadores de línea se eliminan. Si un IOException es encontrado durante la lectura del archivo, es envuelto en un UncheckedIOException, desde Stream no acepta las lambdas que lanzar excepciones comprobadas.

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

    Este Stream necesita un close() llamada; esto está muy poco documentada en la API, y sospecho que muchas personas no se dan cuenta de Stream tiene un close() método. Asegúrese de usar un BRAZO de bloque como se muestra.

    Si está trabajando con una fuente distinta de un archivo, puede utilizar la lines() método en BufferedReader lugar.

    La utilización de la memoria

    El primer método, que conserva los saltos de línea, puede llegar a requerir la memoria de varias veces el tamaño del archivo, ya que por un corto tiempo el archivo raw contenido (una matriz de bytes), y el decodificado de los personajes (cada uno de los cuales es de 16 bits, incluso si codificados en 8 bits en el archivo) residen en la memoria a la vez. Es más seguro para aplicar a los archivos que se saben para ser pequeña en relación con la memoria disponible.

    El segundo método, la lectura de las líneas, es generalmente más eficiente de la memoria, porque la entrada de bytes del búfer de la decodificación no necesita contener el archivo completo. Sin embargo, todavía no es el adecuado para los archivos que son muy grandes para el tamaño de la memoria disponible.

    Para la lectura de archivos de gran tamaño, se necesita un diseño diferente para su programa, que se lee en un fragmento de texto de un arroyo, la procesa, y luego pasa a la siguiente, la reutilización del mismo tamaño fijo de bloque de memoria. Aquí, la «gran» depende de las características del equipo. Hoy en día, este umbral puede ser de varios gigabytes de RAM. El tercer método, utilizando un Stream<String> es una forma de hacer esto, si su entrada «registros» de pasar a ser de líneas individuales. (El uso de la readLine() método de BufferedReader es el procedimiento equivalente a la de este enfoque).

    Codificación de caracteres

    Una cosa que falta de la muestra en el post original es la codificación de caracteres. Hay algunos casos especiales, donde la plataforma por defecto es lo que quieres, pero son raros, y usted debería ser capaz de justificar su elección.

    La StandardCharsets clase de definir algunas constantes para las codificaciones necesarias de todos los tiempos de ejecución de Java:

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

    La plataforma por defecto está disponible desde el Charset clase sí mismo:

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

    Nota: Esta respuesta reemplaza en gran parte de mi Java versión 6. La utilidad de Java 7 con seguridad simplifica el código, y la respuesta anterior, que utiliza un mapa de bytes del búfer, impidió que el archivo que se lea de ser eliminado hasta que el búfer asignado fue el recolector de basura. Usted puede ver la versión antigua a través de la «editar» que aparece en esta respuesta.

    • Muy interesante. ¿Qué hace el canal de medios. Sé que es para evitar bloquear el hilo?» Pueden ser bidireccionales ( o eso es lo que he entendido ), Pero en la más simple palabra, ¿qué son? Usted puede elaborar más?
    • En muchas maneras, un ReadableByteChannel es como un InputStream, y WritableByteChannel es como un OutputStream. Muchos de hormigón Canales de la aplicación de estas interfaces, por lo que un objeto es bi-direccional. Algunos canales (SocketChannel) de apoyo no-bloqueo de IO, pero esto no es cierto para todos los canales.
    • ¿Sabe usted el tiempo – y la memoria de la eficacia de este modismo, o al menos estimar? Es un hermoso idioma!
    • Técnicamente hablando, es O(n) en el tiempo y en el espacio. Cualitativamente, debido a la inmutabilidad requisito de Cadenas, es bastante duro a la memoria; temporalmente, hay dos copias de los datos char en la memoria, además de la sala para el codificado de bytes. Suponiendo que algunos de byte único de codificación, será (temporalmente) requieren de 5 bytes de memoria para cada uno de los caracteres en el archivo. Dado que la pregunta pide específicamente para una Cadena, que es lo que te voy a mostrar, pero si usted puede trabajar con el CharBuffer devuelto por «decode», el requisito de memoria es mucho menor. En cuanto a tiempo, creo que no vas a encontrar nada más rápido en el núcleo de Java libs.
    • Posible error tipográfico? NIO tiene un conjunto de Caracteres (no CharSet) de la clase java.de nio.conjunto de caracteres.Conjunto de caracteres. Esto es lo que CharSet debería haber sido?
    • Nota : después de hacer ejercicio un poco ese código, me enteré de que usted no puede eliminar de forma fiable el archivo a la derecha después de la lectura con este método, que puede ser un problema inexistente en algunos casos, pero no en el mío. Puede ser 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 sufren de este error. De todos modos, sólo quería dar la información, para otras personas, sólo en caso de…
    • Nussbaumer: yo también golpeado en este problema. Increíble que el error ha sido marcado como «No Va a Arreglar». Esto significa esencialmente que FileChannel#map es, en general, inutilizable.
    • Nussbaumer: El error ha sido eliminado de la Oracle / Sun Base de datos de errores: «Este error no está disponible». Google caché del sitio en webcache.googleusercontent.com/search?q=cache:bugs.sun.com/…
    • Traté de leer un archivo exe el uso de este método con el juego de caracteres por defecto, añadir algunos datos en ella y volvió a dejar un exe, Pero dañado el archivo exe, Alguna idea ?
    • Lo que usted describe no tiene sentido. Los archivos EXE no son de texto. Y tienen una estructura bien definida. En primer lugar, destruyendo el contenido del fichero mediante la decodificación como de texto, a continuación, están destruyendo la estructura añadiendo texto. ¿Cómo pudo fallar para corromper el archivo EXE?
    • Yo realmente no se preocupan acerca de la codificación, podría yo sólo uso Charset.defaultCharset() en lugar de tener un argumento de aceptarlo?
    • Si está seguro de que el archivo siempre será codificado con la plataforma del conjunto de caracteres por defecto, sí, que se podía hacer eso. Si hay un desequilibrio, entonces tendrás la atención acerca de la codificación.
    • Como de Java 8, el juego de caracteres puede ser omitido de forma predeterminada, el uso de UTF-8. Por lo tanto la lectura de todas las líneas se convierte en Files.readAllLines(Paths.get("/your/path/to/file"));
    • ¿Cuál es el beneficio de esto: la codificación.decode(ByteBuffer.wrap(codificado)).toString(); frente a esto: new String(codificada, codificación);
    • No hay uno! Creo que fue sólo realizó a través del código original que utiliza un búfer asignado. Gracias por señalándolo.
    • magnifico, java 8 solución
    • En mi caso, yo estaba haciendo esto desde un método estático, así que se veía como este: URL url = NarrationDataProvider.class.getResource(filePath); byte[] encoded = Files.readAllBytes(Paths.get(url.toURI())); return new String(encoded, StandardCharsets.US_ASCII);
    • De lo que se aplican a los compiladores?
    • He intentado utilizar la readFile método de esta respuesta, pero no puedo encontrar donde la Files clase se encuentra. Estoy usando el JDK 1.7.0_79
    • href=»http://docs.oracle.com/javase/7/docs/api/java/nio/file/Files.html» >java.nio.file.Files
    • Por desgracia este fragmento de código no funciona en Android.
    • de trabajo» no es una clara descripción del problema. Lo que sucede? Cuál de los cuatro fragmentos de código están hablando?
    • java.de nio.archivo.Archivos o java.de nio.archivo.Rutas de acceso no es compatible con Android.
    • Bueno, esta pregunta es acerca de Java, no de Android, pero la versión de Java 6 (se puede ver en el historial de edición) funcionará en Android.
    • La «codificación de Caracteres» sección necesita ir ahora que he quitado todas las demás referencias a Apache Commons IO.
    • Que la sección no tiene nada que ver con Apache Commons IO. Es completamente relevante core Java NIO.

  2. 334

    Si usted está dispuesto a utilizar una biblioteca externa, echa un vistazo Apache Commons IO (200 KB JAR). Contiene una org.apache.commons.io.FileUtils.readFileToString() método que permite leer de todo 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);
    }
    • No me parece que ese método en el URL que usted proporcione.
    • Es en la clase org.apache.commons.io.FileUtils
    • Estoy usando FileUtils demasiado, pero me pregunto, ¿qué es mejor entre el uso de FileUtils o aceptado el nio respuesta?
    • La pregunta más importante es si usted se siente cómodo tener una dependencia en una 3ª parte de la biblioteca. Si usted tiene Commons IO o Guayaba en su proyecto, a continuación, utilizar ese (sólo para el código de la sencillez, de lo contrario probablemente no será una diferencia notable).
  3. 176

    Una muy magra solución 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 establecer 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 try-con-recursos bloque, que se llame scanner.close() para usted:

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

    Recordar que el Scanner constructor puede lanzar un IOException. Y no te olvides de importación java.io y java.util.

    Fuente: Pat Niemeyer blog

    • \\De obras debido a que no hay «otro principio del archivo», por lo que son, de hecho, leer el último testigo…que es también la primera. Nunca trató con \\Z. También tenga en cuenta que puede leer cualquier cosa que se pueda leer , como Archivos, InputStreams, canales…yo a veces uso este código para leer de la pantalla de la ventana de eclipse, cuando no estoy seguro de si estoy leyendo un archivo u otro…sí, classpath, me confunde.
    • Como el cartel, me pueden decir la verdad, no sé si y cuando el archivo se cierre correctamente…nunca escribo esto en el código de producción, yo lo uso sólo para los exámenes o de depuración.
    • Tiene un límite de 1024 caracteres creo
    • Escáner implementa Closeable (invoca a cerrar en la fuente), por lo que aunque elegante, no debería ser un one-liner. El tamaño por defecto del buffer es de 1024, pero Escáner aumentar el tamaño según sea necesario (ver Escáner#makeSpace())
    • Esta falla uno de ellos para vaciar los archivos con un java.util.NoSuchElementException.
    • Esta solución permite la lectura de los archivos de los arroyos, por lo que son capaces de leer el correo.g classpath de recursos. El ampliamente sugerido Files.readAllBytes(Paths.get(path)) solución no funciona el correo.g en JEE medio ambiente.
    • También, no olvide llamar trim() en la Cadena resultante, a menos que usted quiere que el \r\n que se adjunta al final.
    • esto puede ser solucionado mediante el uso de sc.findWithinHorizon("(?s).*", 0) en lugar de .useDelimiter("\\A").next(). Entonces, va a coincidir con la totalidad (posiblemente vacía) de archivo en lugar de buscar un separador.
    • ella dependientes del tipo de la ruta de clases y de recursos disponibles del sistema de archivos de las implementaciones. Para los archivos y el módulo de almacenamiento, Files.readAllBytes(Paths.get(url.toURI())) funciona fuera de la caja, mientras que para jar las entradas, tendrás que crear el ZipFileSystem una vez manualmente en el comienzo de su aplicación. Para otros, construcciones especiales, su contenedor tendría que proporcionar el necesario sistema de archivos, que es, de hecho, no se garantiza. Pero desde Java 9, usted puede llamar a readAllBytes() directamente en el InputStream.

  4. 100
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    String content = new String(Files.readAllBytes(Paths.get("readMe.txt")), "UTF-8");

    desde java 7 puedes hacerlo de esta manera.

    • Esto debe ser aceptado como respuesta – sola línea, no externo libs.
    • Debe mencionar la necesaria importación : la importación de java.de nio.archivo.Archivos; import java.de nio.archivo.Rutas de acceso;
    • hecho, &, agregó UTF_8 de java.de nio.charset
  5. 77

    Si usted está buscando una alternativa que no se trata de una librería de terceros (por ejemplo,Commons I/O), puede utilizar el Escáner 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();
        }
    }
    • Creo que esta es la mejor manera. Echa un vistazo java.sun.com/docs/books/tutorial/essential/io/scanning.html
    • El Escáner constructor que acepta una Cadena de no tratar a la cadena como el nombre de un archivo para leer, pero como el texto para ser escaneados. Yo cometí ese error todo el tiempo. :-/
    • buena captura. He editado el Don de la respuesta ligeramente para arreglar eso (espero).
    • fileContents.append(escáner.nextLine()).append(lineSeparator);
    • Cambiar la instrucción de inicialización para Scanner scanner = new Scanner((Readable) new BufferedReader(new FileReader(file)));. De lo contrario, usted puede capturar sólo una parte del archivo.
    • Este método de añadir un extra de separador al final del archivo, cuando no hay una en el archivo real (para un archivo que termina con ningún salto de línea).
    • ¿Por qué es eso?

  6. 67

    La guayaba tiene un método similar a la de Commons IOUtils que Willi aus Rohr mencionado:

    import com.google.common.base.Charsets;
    import com.google.common.io.Files;
    
    //...
    
    String text = Files.toString(new File(path), Charsets.UTF_8);

    EDICIÓN por PiggyPiglet

    Files#toString está en desuso, debido a la eliminación de Octobor 2019. En lugar de utilizar
    Files.asCharSource(new File(path), StandardCharsets.UTF_8).read();

    EDICIÓN por Oscar Reyes

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

    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 reciente Guayaba versiones. Para la fuente actual, ver las clases de Los archivos, CharStreams, ByteSource y CharSource en com.google.común.io paquete.

    • Este código ha de fundición de largo a int que podría emergente algunos locos comportamiento con archivos de gran tamaño. Tiene espacios extra y donde se cierra el inputstream?
    • La secuencia de es cerrado, tenga en cuenta el uso de Closer en CharSource. El código de la respuesta no es la real, actual Guayaba fuente.
  7. 53
    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 "";
        }
    • O aún más simple: new String(Files.readAllBytes(FileSystems.getDefault().getPath( filename)));
    • o new String(Files.readAllBytes(Paths.get(filename))); 🙂
    • Bien jugado, y para guardar el tipo de al lado, el de Google, Paths es aparentemente 1.7+ como FileSystems. (¡Caramba!)
    • ;S una vergüenza que esta respuesta no tiene más votos. Yo estaba buscando la manera más rápida y más sencilla para obtener un archivo de texto en una Cadena. Este es el y si no me desplácese hacia abajo y abajo y abajo, me habría perdido. El OP debería considerar la posibilidad de aceptar esta respuesta para moverlo a la parte superior.
    • Esta respuesta ha horrible error de manipulación. No utilice este método en el código de producción, o mejor: nunca.
  8. 50

    Que el código que se va a normalizar los saltos de línea, que puede o puede no ser lo que realmente queremos hacer.

    Aquí una alternativa que no hace eso, y que es (OMI) más sencillo de entender que el NIO código (aunque aún se utiliza 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();
        }        
    }
    • Perdóname por la reactivación de un comentario a esta edad, pero, ¿te refieres a pasar en un objeto String llamado «archivo», o que debe ser un objeto de Archivo en su lugar?
  9. 49

    Si usted necesita una cadena de procesamiento (procesamiento paralelo) de Java 8 tiene la gran Corriente de la API.

    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

    Más ejemplos están disponibles en el JDK muestras sample/lambda/BulkDataOperations que puede ser descargado desde Oracle Java SE 8 página de descarga

    Otro forro ejemplo

    String out = String.join("\n", Files.readAllLines(Paths.get("file.txt")));
    • Hace el .paralelo() ocurre después de leer las líneas o antes de eso?
    • Verdadero trabajo comienza desde la terminal de operación de recoger(…) se invoca. Stream es perezosamente poblada línea por línea. No es necesario leer todo el archivo en la memoria antes de que el procesamiento (por ejemplo, el filtrado y la asignación).
    • recortar antes de la elección de no-líneas vacías?
  10. 26

    Se reunieron todas las formas posibles para leer el Archivo como una Cadena de Disco o de Red.

    • Guayaba: Google el uso de clases Recursos, Archivos

      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 el uso de 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 utilizando 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()));
      }

    • Escáner de Clase con regex \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 utilizando 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 el 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

  11. 25

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

    Tiene el siguiente método

    public static String readFileToString(File file) throws IOException

    Si desea que las líneas como una lista de uso

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

    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
    • ¿Por qué, oh, por qué, introducir nuevos métodos que se basan en el juego de caracteres por defecto en el 2018 ?
    • este método no se basa en el juego de caracteres del sistema. Por defecto es UTF-8, que está muy bien.
    • estás en lo cierto ! lo hace de Archivos.readAllLines ! que hace que los archivos de la API no es muy coherente con los métodos más antiguos, pero es para mejor 🙂
  13. 16

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

    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 de los atajos, por lo que la 3ª parte de las bibliotecas no siempre son necesarios para simples operaciones de archivo.

  15. 15

    Java intenta ser muy general y flexible en todo lo que hace. Como resultado, algo que es relativamente sencillo en un lenguaje de secuencias de comandos (el código sería reemplazado con «open(file).read()» en python) es mucho más complicado. No parece ser más corto manera de hacerlo, excepto el uso de una librería externa (como Willi aus Rohr mencionado). Sus opciones:

    • El uso de una biblioteca externa.
    • Copia este código en todos sus proyectos.
    • Crear su propio mini-biblioteca, que contiene funciones de uso frecuente.

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

    • Yeap. Esto hace que el «alto» nivel de lenguaje toma un significado diferente. Java es nivel alto en comparación con C, pero bajo en comparación con Python o Ruby
    • De acuerdo en que Java es larga de alto nivel de abstracción, pero corto en métodos de conveniencia
    • Cierto, Java tiene un número increíble de formas de tratar con Archivos y muchos de ellos se parecen complicadas. Pero esto es bastante cercano a lo que tenemos en lenguajes de alto nivel: byte[] bytes = Files.readAllBytes(someFile.toPath());
  16. 11

    Mediante el JDK 8 o más:

    no hay librerías externas utilizadas

    Puede crear un nuevo objeto String en el archivo de contenido (a través de clases de java.nio.file paquete):

    public String readStringFromFile(String filePath) throws IOException {
        String fileContent = new String(Files.readAllBytes(Paths.get(filePath)));
        return fileContent;
    }
    • Duplicado de Moritz Petersen respuesta que escribió:String contenido = new String(Archivos.readAllBytes(Rutas de acceso.get(nombre de archivo)), «UTF-8»);
  17. 8

    Hay 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 la 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);
    }
    • Esto va a cambiar el carácter de nueva línea para el valor predeterminado newline elección. Esto puede ser deseable o no.
    • Revierte la edición a esta respuesta, porque el punto es limitar el ámbito de la line variable. La edición declarado dos veces, lo que sería un error de compilación.
  18. 7

    Si usted no tiene acceso a la Files clase, 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);
    }
    • ejemplo de código de caracteres para invocar?
  19. 4

    Una solución flexible utilizando 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 los archivos), por ejemplo, cuando la lectura de una dirección URL.

  20. 3

    Tener en cuenta al utilizar fileInputStream.available() devuelve el entero no tiene que representan el tamaño real del archivo, sino la adivinado cantidad de bytes que el sistema debe ser capaz de leer a partir de la corriente sin el bloqueo de la IO. Un simple y seguro de manera que podría parecer a esto

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

    Se debe considerar que este enfoque es no adecuado para multi-byte codificaciones de caracteres como UTF-8.

    • Este código puede dar resultados impredecibles. De acuerdo a la documentación de la available() método, no hay ninguna garantía de que el final del archivo que se alcanza en el caso de que el método devuelve 0. En ese caso, usted podría terminar con una incompleta archivo. Lo que es peor, el número de bytes realmente leer puede ser menor que el valor devuelto por available(), en cuyo caso se corrompe salida.
  21. 3

    Esta usa el método RandomAccessFile.readFully, parece estar disponibles a partir de 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
            }
        }
    }
  22. 3

    Usted puede tratar de Escáner y de la clase de Archivo, un par de líneas de solución

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

    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);
    }
  24. 3
    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();
    }
    • Yo creo que esto tiene el inconveniente que os utilización de la plataforma de codificación predeterminada. +1 de todos modos 🙂
    • Me parece a mí que el bloque finally no sabe variables definidas en el bloque try. javac 1.6.0_21 produce el error cannot find symbol.
    • Tiene usted incluso trató de su propio código? Usted ha definido lector en bloque try/catch, por lo que no será accesible en el bloque finally.
  25. 2

    Después de Ctrl+F ing después de Escáner, creo que la solución de Escáner debe ser mencionados también. En el más fácil de leer de la moda que es como sigue:

    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 el uso de Java 7 o más reciente (y debe) considerar el uso de try-con-recursos para hacer el código más fácil de leer. No hay más punto de cerrar cosas ensuciando todo. Pero eso es sobre todo una elección estilística a mi entender.

    Estoy publicando esto sobre todo para completionism, ya que si usted necesita para hacer de esto un montón, no debe haber cosas en java.de nio.archivo.Los archivos que debe hacer el trabajo mejor.

    Mi sugerencia sería la de utilizar Archivos#readAllBytes(Ruta de acceso) para agarrar todos los bytes, y alimentar a los nuevos String(byte[] conjunto de Caracteres) para obtener una Cadena de la que usted puede confiar. Los juegos de caracteres se significa para usted durante el resto de su vida, así que ten cuidado con esto ahora.

    Que otros han dado el código y esas cosas, y no quiero robarle su gloria. 😉

  26. 2

    También si el archivo pasa a ser dentro de una jarra, también puede utilizar este:

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

    La ruta debe comenzar con / por ejemplo, si el frasco es

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

    A continuación, desea invocar como este:

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

    En una línea (Java 8), suponiendo que tiene un Lector:

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

    Basa en @erickson respuesta, se puede utilizar:

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

    No puedo comentar otras entradas todavía, así que voy a dejarlo 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 se pone la nueva línea de char en el final de la cadena, que puede causar algunos weirds errores. Mi sugerencia es cambiar 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();
        }
    }
    • En el primer caso es posible que se añade un extra de nueva línea al final. en el segundo caso, usted podría ser la omisión de uno. Así que ambos son igual de mal. Consulte este artículo
  30. 0

    Utilice el código:

    File file = new File("input.txt");
    BufferedInputStream bin = new BufferedInputStream(new FileInputStream(
                    file));
    byte[] buffer = new byte[(int) file.length()];
    bin.read(buffer);
    String fileStr = new String(buffer);

    fileStr contiene la producción en Cadena.

  31. -2

    en java 8 , hay una nueva Clase

    java.util.stream.Flujo de

    Una secuencia representa una secuencia de elementos y soporta diferentes tipos de operaciones para realizar cálculos sobre aquellos elementos

    para Leer más sobre esto :

    Documentación De Oracle

    Aquí un Ejemplo :

    import java.nio.charset.StandardCharsets;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    import java.util.stream.Stream;
    
    public Class ReadFile{
      public  static String readFile(String filePath) {
     StringBuilder  stringBuilder = new StringBuilder();
        String ls = System.getProperty("line.separator");
            try {
    
                try (Stream<String> lines = Files.lines(Paths.get(filePath), StandardCharsets.UTF_8)) {
                    for (String line : (Iterable<String>) lines::iterator) {
    
    
                          stringBuilder.append(line);
                          stringBuilder.append(ls);
    
    
                    }
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            }
    
          return stringBuilder.toString(); 
    
    
    }
    
    }

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea