txt - Utilidades para leer el archivo de texto de recursos en String(Java)

leer y escribir en archivo de texto java

Question

¿Hay alguna utilidad que ayude a leer un archivo de texto en el recurso en una Cadena? Supongo que este es un requisito popular, pero no pude encontrar ninguna utilidad después de buscar en Google.

Answer 1

Solución Java 8 pura y simple

Este sencillo método a continuación funcionará bien si está usando Java 8:

/**
 * Reads given resource file as a string.
 *
 * @param fileName the path to the resource file
 * @return the file''s contents or null if the file could not be opened
 */
public String getResourceFileAsString(String fileName) {
    InputStream is = getClass().getClassLoader().getResourceAsStream(fileName);
    if (is != null) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        return reader.lines().collect(Collectors.joining(System.lineSeparator()));
    }
    return null;
}

Y también funciona con recursos en archivos jar.

No hay necesidad de bibliotecas grandes y gordas. A menos que ya esté usando Guava o Apache Commons IO, agregar esas bibliotecas a su proyecto solo para poder leer un archivo como una cadena parece demasiado.

Cargando desde un contexto estático

Como esto suele ser una función de utilidad, probablemente querrá que sea accesible desde una clase de utilidades estáticas. Cambié la implementación un poco para que el método se pueda declarar como estático. Funciona igual. Aquí está:

/**
 * Reads given resource file as a string.
 *
 * @param fileName the path to the resource file
 * @return the file''s contents or null if the file could not be opened
 */
static String getResourceFileAsString(String fileName) {
    ClassLoader classLoader = ClassLoader.getSystemClassLoader();
    InputStream is = classLoader.getResourceAsStream(fileName);
    if (is != null) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        return reader.lines().collect(Collectors.joining(System.lineSeparator()));
    }
    return null;
}

Answer 2

A menudo tuve este problema yo mismo. Para evitar dependencias en proyectos pequeños, a menudo escribo una pequeña función de utilidad cuando no necesito commons io o tal. Aquí está el código para cargar el contenido del archivo en un buffer de cadena:

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

Especificar la codificación es importante en ese caso, porque puede haber editado su archivo en UTF-8, y luego ponerlo en un contenedor, y la computadora que abre el archivo puede tener CP-1251 como su codificación de archivo nativo (por ejemplo) ; por lo que en este caso nunca se conoce la codificación de destino, por lo tanto, la información de codificación explícita es crucial. Además, el ciclo para leer el archivo char por char parece ineficaz, pero se usa en un BufferedReader, y de hecho bastante rápido.

Answer 3

Aquí está mi enfoque funcionó 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
    }
}

Answer 4

Con el conjunto de importaciones estáticas, la solución de guayaba puede ser muy compacta de una sola línea:

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

Se requieren las siguientes importaciones:

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

Answer 5

Estoy usando lo siguiente para leer los archivos de recursos del 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() : "";
        }
    }
}

No se requieren dependencias de terceros.

Answer 6

Guava también tiene 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 here para comparar 3 formas ( BufferedReader vs. Guava''s Files vs. Guava''s Resources ) para obtener String de un archivo de texto.

Answer 7

He escrito métodos readResource () aquí , para poder hacerlo en una invocación simple. Depende de la biblioteca de Guava, pero me gustan los métodos exclusivos de JDK sugeridos en otras respuestas y creo que los cambiaré de esa manera.

Answer 8

Para java 7:

new String(Files.readAllBytes(Paths.get(getClass().getResource("foo.txt").toURI())));

Answer 9

Puede usar el siguiente código de Java

    new String(Files.readAllBytes(Paths.get(getClass().getResource("example.txt").toURI())));

Answer 10

Puede usar el viejo sobrenombre de truco del escáner estúpido para hacer eso sin ninguna dependencia adicional como la guayaba:

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

Chicos, no utilicen cosas de terceros a menos que realmente lo necesiten. Ya hay mucha funcionalidad en el JDK.

Answer 11

Si desea obtener su cadena de un recurso del proyecto como el archivo testcase / foo.json en src / main / resources en su proyecto, haga esto:

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

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

Answer 12

Usa los FileUtils de Apache commons. Tiene un método readFileToString

Answer 13

Guava tiene un método "toString" para leer 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 la respuesta anterior de ).

Answer 14

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

Answer 15

Sí, Guava proporciona esto en la clase de Resources . Por ejemplo:

URL url = Resources.getResource("foo.txt");
String text = Resources.toString(url, Charsets.UTF_8);

Answer 16

yegor256 ha encontrado una buena solución usando Apache Commons IO :

import org.apache.commons.io.IOUtils;

String text = IOUtils.toString(this.getClass().getResourceAsStream("foo.xml"),
                               "UTF-8");

Answer 17

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