Hay alguna utilidad que ayuda a leer un archivo de texto en el recurso en una Cadena. Supongo que esto es un requisito habitual, pero no pude encontrar ninguna utilidad después de Googlear.

  • por favor aclarar a qué te refieres por «recursos de archivo de texto» vs «archivo de texto en el recurso» – no es fácil entender lo que usted está tratando de lograr.
  • Eso es simplemente un archivo de texto en el classpath como «ruta de clases*:mytext/text.txt»
InformationsquelleAutor Loc Phan | 2011-05-20

20 Comentarios

  1. 287

    Sí, La guayaba proporciona esta en la Recursos clase. Por ejemplo:

    URL url = Resources.getResource("foo.txt");
    String text = Resources.toString(url, Charsets.UTF_8);
    • Esto es genial, sin embargo para aplicaciones web podría no ser la mejor solución, la implementación de getResource es el uso de Resource.class.getClassLoader pero en las aplicaciones web, esto podría no ser «su» clase loader, por lo que se recomienda (por ejemplo, en [1]) para el uso de Thread.currentThread().getContextClassLoader().getResourceAsStream lugar (referencia [1]: stackoverflow.com/questions/676250/…)
    • Sí, si usted quiere el contexto del cargador de clases que quieres utilizar de forma explícita.
    • En el caso especial cuando el recurso está al lado de su clase, se puede hacer Resources.toString(MyClass.getResource("foo.txt"), Charsets.UTF_8) que garantiza el uso correcto de la clase loader.
    • Qué versión de Java que está utilizando? Puede haber algo en Java 7 o Java 8…
    • Bueno, por supuesto que puede leer sus archivos de recursos, sin nada extra. Sólo tienes que crear una BufferedReader alrededor de un InputStreamReader alrededor de su flujo de recursos, leer un fragmento del tiempo y anexar a un StringBuilder. Usted debe ser capaz de hacer toda la cosa, en alrededor de 15 líneas de código, que debo pensar. Mirando a su alrededor JDK 8, yo no le veo nada masivamente más simple, aunque 🙁
    • Se ve como la Guayaba del Resource.getResource (fuente) ahora utiliza su método recomendado.
    • Nota para Java 7 y más adelante: Charsets deben ser tratados como obsoleto; el uso java.nio.charset.StandardCharsets lugar.
    • com.google.common.io.Resources está marcado inestable de acuerdo con SonarQube
    • Parece que todavía tiene la @Beta tag – pero, personalmente, me sorprendería si se retira en este momento.

  2. 157

    Puede utilizar el antiguo Estúpido Escáner truco oneliner de hacerlo sin ningún adicional de dependencia como la guayaba:

    String text = new Scanner(AppropriateClass.class.getResourceAsStream("foo.txt"), "UTF-8").useDelimiter("\A").next();

    Chicos, no utilice la 3ª parte de las cosas a menos que usted realmente necesita. Hay un montón de funcionalidades en el JDK ya.

    • Evitar la 3ª parte es razonable principio. Por desgracia, el núcleo de la biblioteca parece alérgica a la modelización de la vida real de casos de uso. Mira Java 7 Archivos, y dime por qué leer de todo, desde una ruta de clases de recursos no incluido no? O por lo menos con un estándar de ‘sistema de archivos’.
    • Es – o no es – necesario para cerrar la secuencia así? La guayaba internamente cierra la secuencia.
    • Trabajó muy bien para mí también! Estoy de acuerdo acerca de la 3ª parte de la cosa también: En muchas de las respuestas, la respuesta predeterminada siempre parece ser la utilización de una tercera parte de la biblioteca – es el caso de Apache o de alguien más.
    • cambio CartApplication.class.getResourceAsStream a CartApplication.class.getClassLoader().getResourceAsStream para cargar recursos en la actual tarro..como srm/test/resources
    • Mientras que la he usado, estoy totalmente de acuerdo en evitar la 3ª parte de los paquetes. El hecho de que en Java, la única forma de facilidad de lectura de un archivo a la cadena con el escáner truco es bastante triste. La alternativa al uso de una 3 ª parte lib es que todo el mundo acaba de crear sus propios envoltorios. La guayaba para IO manos hacia abajo gana si usted tiene un montón de necesidades para este tipo de operación. Donde estoy de acuerdo es que no debe importar una 3ra parte del paquete si usted sólo tiene un lugar en el código donde quieres hacer esto. Que sería una exageración de la omi.
    • Solución agradable, sin embargo no funciona cuando el recurso/secuencia está vacía, ya que el Escáner emitirá una NoSuchElementException en ese caso. Para que el código funcione en todos los casos envoltura de la instrucción de un try-catch y «usar» un espacio vacío cuando se detecta. Lamentablemente esto ya no es de una sola línea.

  3. 84

    Para java 7:

    new String(Files.readAllBytes(Paths.get(getClass().getResource("foo.txt").toURI())));
    • Explique por favor por qué esto funciona, por qué es mejor que otras alternativas, y cualquier rendimiento/codificación de consideraciones necesarias.
    • Es nio 2 en java 1.7. Es nativa de feture de java. Para la codificación de uso de la nueva Cadena de caracteres(bytes, StandardCharsets.UTF_8)
    • No funciona cuando el recurso está en el frasco
    • en mi caso necesitaba getClass().getClassLoader() pero otra gran solución!
    • Esto no va a funcionar, una vez que la aplicación es un paquete dentro de un frasco.
  4. 57

    La guayaba tiene un «toString» método para la lectura de un archivo en una Cadena:

    import com.google.common.base.Charsets;
    import com.google.common.io.Files;
    
    String content = Files.toString(new File("/home/x1/text.log"), Charsets.UTF_8);

    Este método no requiere que el archivo esté en el classpath (como en Jon Skeet respuesta anterior).

    • O si se trata de una secuencia de entrada, la guayaba tiene un buen camino para que esto así String stringFromStream = CharStreams.toString(new InputStreamReader(resourceAsStream, "UTF-8"));
    • Este es obsoleta en la Guayaba 24.1
  5. 49

    Pura y simple, jar-friendly, Java 8+ solución

    Este sencillo método a continuación va a hacer muy bien si usted está usando Java 8 o mayor:

    /**
     * Reads given resource file as a string.
     *
     * @param fileName path to the resource file
     * @return the file's contents
     * @throws IOException if read fails for any reason
     */
    static String getResourceFileAsString(String fileName) throws IOException {
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        try (InputStream is = classLoader.getResourceAsStream(fileName)) {
            if (is == null) return null;
            try (InputStreamReader isr = new InputStreamReader(is);
                 BufferedReader reader = new BufferedReader(isr)) {
                return reader.lines().collect(Collectors.joining(System.lineSeparator()));
            }
        }
    }

    Y también obras con recursos en archivos jar.


    Evitar dependencias innecesarias

    Siempre prefieren no depender de grandes, la grasa de las bibliotecas. A menos que usted ya está usando la Guayaba o Apache Commons IO para otras tareas, la adición de las bibliotecas para su proyecto sólo para ser capaz de leer de un archivo parece un poco demasiado.

    «Simple» método? Usted debe estar bromeando

    Entiendo que Java puro no hacer un buen trabajo cuando se trata de hacer tareas simples como este. Por ejemplo, esta es la forma de leer de un archivo en Node.js:

    const fs = require("fs");
    const contents = fs.readFileSync("some-file.txt", "utf-8");

    Simples y fáciles de leer (aunque la gente todavía como para confiar en muchas dependencias de todos modos, debido, principalmente, a la ignorancia). O en Python:

    with open('some-file.txt', 'r') as f:
        content = f.read()

    Es triste, pero es todavía simple para Java normas y todo lo que tienes que hacer es copiar el método anterior para su proyecto y el uso de la misma. Incluso no me pregunte usted entienda lo que está pasando ahí, porque realmente no importa a nadie. Simplemente funciona, periodo 🙂

    • por favor intenta mantener tu comentario constructivo. A medida que crecen como una madura desarrollador, aprender que a veces quiere «reinventar la rueda». Por ejemplo, usted puede necesitar para mantener su binario algo por debajo de umbral de tamaño. A menudo las bibliotecas hacer que su aplicación el tamaño de crecer por órdenes de magnitud. Uno podría argumentar justo lo contrario de lo que usted dijo: «No hay necesidad de escribir código. Sí, vamos a importar las bibliotecas en cada momento». ¿De verdad prefieren importar una biblioteca sólo para ahorrar 3 líneas de código? Apuesto a que la adición de la biblioteca que va a aumentar su LOC por más que eso. La clave es el equilibrio.
    • Por cierto, acabo de ver que has publicado aquí una respuesta así diciendo que escribió algunos de los métodos en su propia biblioteca, dependiendo de la Guayaba, pero que «como JDK-sólo métodos sugeridos en otras respuestas y [que] creo [que]’ll cambiar estas de esa manera». Es bueno saberlo, me alegro de que me podría ayudar 🙂
    • [¿De verdad prefieren importar una biblioteca sólo para ahorrar 3 líneas de código] ==> teniendo en cuenta que me estoy quedando cosas en servidores en la nube, cada uno con un mínimo de 16 gb de RAM, claro que yo lo hago. Yo uso C (o Ensamblador) si tuviera C=64 requisitos de hardware. En un mundo en el que tener legible, factorised, menos propenso a errores de código es generalmente más importante que el ahorro de unos pocos Kb.
    • Bueno, no todo está ejecutando cosas en la nube. Hay sistemas embebidos en todas partes en ejecución de Java, por ejemplo. Yo no veo el punto en criticar a las respuestas que proporcionan totalmente enfoques válidos, dado que lo dices a ti mismo que vas a aceptar la sugerencia de utilizar el JDK directamente en su propio código. De todos modos, vamos por favor, trate de mantener los comentarios estrictamente para ayudar a mejorar las respuestas, no para discutir opiniones.
    • Mi crítica no es a la «no Hay necesidad de grandes, gordos bibliotecas» parte. La guayaba o Apache Commons son sólo unos pocos KBs (o MBs, por lo que importa) y, en la mayoría de los casos, la reutilización de ellos cuando se necesita una funcionalidad que ya están realizando es preferible ahorrar unos pocos KBs (tal vez no es bueno para sistemas embebidos, pero que no es la típica JDK de uso).
    • I plan para la reutilización del JDK para implementar mi readResource() los métodos, porque yo no veo ningún método sencillo en el JDK para ello, como mínimo que se necesita para escribir un largo feo línea cada vez, o peor, vuelva a implementar el método de arriba cada vez. Así que, usando mi jUtils lib haría el «gordo» de la biblioteca de todo 🙂 por CIERTO: he dividido recientemente, la causa se había vuelto demasiado grande y tirando demasiadas dependencias, así que me preocupan demasiado acerca de los tamaños de componentes, no estoy obsesionado con él, a expensas de las buenas prácticas de ingeniería de software 🙂
    • Bueno JDK-la única solución. Yo sólo añadiría comprobar si InputStream variable is es null o no.
    • Gracias por tu sugerencia, @scrutari.
    • De niza. He utilizado este. Usted puede considerar el cierre de los arroyos/lectores también.
    • Sí… parece a mí que no hay nada de clausura de los arroyos.
    • Buena captura, @ArtOfWarfare (y también @dimplex). Editado el código a utilizar try-con-los recursos de la declaración.
    • ¿Qué acerca de la InputStreamReader y BufferedReader? ¿Los que no también necesita obtener cerrado? (Pregunta sincera – IDK, pero veo que BufferedReader tiene un close() método disponible…)
    • Estoy totalmente perdido, gracias por señalarlo. Tomé la oportunidad y reescribió la mayor parte de la respuesta. También me cayó el método no estático (static uno funciona para todos los casos, así que vamos a mantenerlo simple).

  6. 40

    yegor256 ha encontrado un solución agradable el uso de Apache Commons IO:

    import org.apache.commons.io.IOUtils;
    
    String text = IOUtils.toString(this.getClass().getResourceAsStream("foo.xml"),
                                   "UTF-8");
    • Yo prefiero «» a este en caso de que esto no está disponible
    • Tan compacto, pero con el cierre de la secuencia de entrada: IOUtils.toString(this.getClass().getResource("foo.xml"), "UTF-8").
    • Si esta solución no funciona, trate de añadir getClassLoader() para el método de la cadena: String text = IOUtils.toString( getClass().getClassLoader().getResourceAsStream("foo.xml"), StandardCharsets.UTF_8);
  7. 37

    apache commons-io tiene un nombre de utilidad FileUtils:

    URL url = Resources.getResource("myFile.txt");
    File myFile = new File(url.toURI());
    
    String content = FileUtils.readFileToString(myFile, "UTF-8");  //or any other encoding
    • ¿Por qué uno tiene que especificar la codificación, no entiendo eso. Si puedo leer el archivo, solo quiero que lo que está en él, debe averiguar lo que la codificación es como mi editor. Cuando he abierto en el Bloc de notas o ++, no me digas qué codificación se debe utilizar. Estoy utilizando este método y, a continuación, después writeStringToFile … pero el contenido es diferente. Me extrañas fichas en el archivo clonado.. no entiendo por qué tendría que especificar una codificación.
    • la elección de la codificación del derecho es un algoritmo muy complejo. Se implementa a menudo en el editor de texto, pero a veces no se detecta la codificación correcta. Yo no esperaría una lectura de archivos de la API para integrar tales complejo algoritmo que lea mi archivo.
    • Además, los algoritmos que hacen uso de la información como idioma del sistema operativo, configuración regional y otra configuración regional que significa que la lectura de un archivo sin especificar una codificación puede trabajar en su configuración, pero no en el de alguien más.
    • Apache FileUtils.readLines(archivo) & copyURLToFile(URL, tempFile).
    • Lo siento por downvoting, pero no me gustan las respuestas que añadir grandes dependencias triviales problemas.
    • No creo que esto funcionará si el recurso se encuentra dentro de un frasco. Entonces no va a ser un archivo.

  8. 16

    A menudo he tenido este problema yo mismo. Para evitar dependencias en proyectos pequeños, a menudo me
    escribir una pequeña función de utilidad cuando no necesito commons io o tal. Aquí es
    el código para cargar el contenido del archivo en una cadena de caracteres en el búfer :

    StringBuffer sb = new StringBuffer();
    
    BufferedReader br = new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("path/to/textfile.txt"), "UTF-8"));
    for (int c = br.read(); c != -1; c = br.read()) sb.append((char)c);
    
    System.out.println(sb.toString());   

    La especificación de la codificación de es importante en ese caso, porque podría tener
    editado el archivo en UTF-8, y a continuación, poner en un frasco, y el equipo que se abre
    el archivo puede tener CP-1251 como su nativo de codificación de archivos (por ejemplo); por lo que en
    este caso nunca se sabe el destino de codificación, por lo tanto el explícito
    la codificación de la información es crucial.
    También el bucle para leer el archivo char char parece ineficiente, sino que se utiliza en un
    Clases bufferedreader, y de manera bastante rápida.

  9. 13

    Puede utilizar la siguiente forma de código Java

    new String(Files.readAllBytes(Paths.get(getClass().getResource("example.txt").toURI())));
    • funciona, cuando el recurso está en el archivo jar?
    • Lo que las sentencias de importación son necesarios para extraer en «Archivos» y «Caminos» de las clases?
    • ambos son parte de java.de nio.archivo de paquete disponible a partir de JDK 7+
  10. 4

    Si usted desea conseguir su Cadena a partir de un proyecto de recursos como el archivo
    testcase/foo.json en src/main/resources en su proyecto, hacer esto:

    String myString= 
     new String(Files.readAllBytes(Paths.get(getClass().getClassLoader().getResource("testcase/foo.json").toURI())));

    Tenga en cuenta que el getClassLoader() método que falta en algunos de los otros ejemplos.

  11. 2

    Estoy usando el siguiente para la lectura de archivos de recursos de la classpath:

    import java.io.IOException;
    import java.io.InputStream;
    import java.net.URISyntaxException;
    import java.util.Scanner;
    
    public class ResourceUtilities
    {
        public static String resourceToString(String filePath) throws IOException, URISyntaxException
        {
            try (InputStream inputStream = ResourceUtilities.class.getClassLoader().getResourceAsStream(filePath))
            {
                return inputStreamToString(inputStream);
            }
        }
    
        private static String inputStreamToString(InputStream inputStream)
        {
            try (Scanner scanner = new Scanner(inputStream).useDelimiter("\A"))
            {
                return scanner.hasNext() ? scanner.next() : "";
            }
        }
    }

    Ningún tercero dependencias requeridas.

  12. 1

    Aquí está mi enfoque funcionaba bien

    public String getFileContent(String fileName) {
        String filePath = "myFolder/" + fileName+ ".json";
        try(InputStream stream = Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath)) {
            return IOUtils.toString(stream, "UTF-8");
        } catch (IOException e) {
            //Please print your Exception
        }
    }
    • ¿Dónde IOUtils vienen? La fuente debe ser que se hace referencia claramente.
  13. 1
    package test;
    
    import java.io.InputStream;
    import java.nio.charset.StandardCharsets;
    import java.util.Scanner;
    
    public class Main {
        public static void main(String[] args) {
            try {
                String fileContent = getFileFromResources("resourcesFile.txt");
                System.out.println(fileContent);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        //USE THIS FUNCTION TO READ CONTENT OF A FILE, IT MUST EXIST IN "RESOURCES" FOLDER
        public static String getFileFromResources(String fileName) throws Exception {
            ClassLoader classLoader = Main.class.getClassLoader();
            InputStream stream = classLoader.getResourceAsStream(fileName);
            String text = null;
            try (Scanner scanner = new Scanner(stream, StandardCharsets.UTF_8.name())) {
                text = scanner.useDelimiter("\A").next();
            }
            return text;
        }
    }
  14. 1

    Al menos a partir de Apache commons-io 2.5, el IOUtils.método toString() admite una URI argumento y devuelve el contenido de los archivos que se encuentran en el interior de los frascos en la ruta de clases:

    IOUtils.toString(SomeClass.class.getResource(...).toURI(), ...)
  15. 0

    La guayaba también ha Files.readLines() si desea un valor de retorno como List<String> línea-por-línea:

    List<String> lines = Files.readLines(new File("/file/path/input.txt"), Charsets.UTF_8);

    Consulte aquí para comparar 3 maneras (BufferedReader vs Guayaba del Files vs Guayaba del Resources) para obtener String desde un archivo de texto.

  16. 0

    Con el conjunto de la estática de las importaciones, la Guayaba, la solución puede ser muy compacto con una sola línea:

    toString(getResource("foo.txt"), UTF_8);

    Las importaciones siguientes son necesarios:

    import static com.google.common.io.Resources.getResource
    import static com.google.common.io.Resources.toString
    import static java.nio.charset.StandardCharsets.UTF_8
  17. 0

    He escrito readResource() métodos de aquí, para ser capaz de hacerlo en una simple invocación. Depende de la Guayaba de la biblioteca, pero me gusta JDK-sólo métodos sugeridos en otras respuestas y creo que voy a cambiar estas de esa manera.

  18. 0

    Si son la Guayaba, entonces usted puede utilizar:

    String fileContent = Files.asCharSource(new File(filename), Charset.forName("UTF-8")).read();

    (Otras soluciones mencionadas otro método para la Guayaba pero están en desuso)

  19. -2
    public static byte[] readResoureStream(String resourcePath) throws IOException {
        ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
        InputStream in = CreateBffFile.class.getResourceAsStream(resourcePath);
    
        //Create buffer
        byte[] buffer = new byte[4096];
        for (;;) {
            int nread = in.read(buffer);
            if (nread <= 0) {
                break;
            }
            byteArray.write(buffer, 0, nread);
        }
        return byteArray.toByteArray();
    }
    
    Charset charset = StandardCharsets.UTF_8;
    String content = new   String(FileReader.readResoureStream("/resource/...*.txt"), charset);
    String lines[] = content.split("\n");
    • Por favor, añada breve explicación a su respuesta.
    • El código es leído archivo de texto de recursos por parte de las líneas de

Dejar respuesta

Please enter your comment!
Please enter your name here