it-swarm.com.de

Utils zum Lesen der Ressource-Textdatei in String (Java)

Gibt es ein Dienstprogramm, das beim Einlesen einer Textdatei in der Ressource in einen String hilft? Ich nehme an, dass dies eine beliebte Anforderung ist, aber nach dem Googeln konnte ich keinen Nutzen finden.

173
Mon Dev

Ja, Guava liefert dies in der Resources Klasse. Zum Beispiel:

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

Sie können den alten Stupid Scanner-Trick oneliner verwenden, um dies ohne zusätzliche Abhängigkeit wie Guave zu tun:

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

Jungs, verwenden Sie keine Sachen von Drittanbietern, es sei denn, Sie brauchen das wirklich. Das JDK verfügt bereits über viele Funktionen.

141
akosicki

Für Java 7:

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

Guava hat eine "toString" -Methode zum Lesen einer Datei in einen String:

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

Diese Methode erfordert nicht, dass sich die Datei im Klassenpfad befindet (wie in Jon Skeet vorherige Antwort).

56

Apache-commons-io hat einen Dienstnamen FileUtils:

URL url = Resources.getResource("myFile.txt");
File myFile = new File(url.toURI());

String content = FileUtils.readFileToString(myFile, "UTF-8");  // or any other encoding
36
Andreas_D

yegor256 hat mit Apache Commons IO eine Nice-Lösung gefunden :

import org.Apache.commons.io.IOUtils;

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

Reine und einfache Java 8-Lösung

Diese einfache Methode eignet sich gut, wenn Sie Java 8 verwenden:

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

Und es funktioniert auch mit Ressourcen in JAR-Dateien.

Es gibt keine Notwendigkeit für große, fette Bibliotheken. Wenn Sie nicht bereits Guava oder Apache Commons IO verwenden, ist das Hinzufügen dieser Bibliotheken zu Ihrem Projekt, nur um eine Datei als Zeichenfolge lesen zu können, etwas zu viel.


Laden aus einem statischen Kontext

Da dies normalerweise eine Dienstprogrammfunktion sein soll, wird es wahrscheinlich von einer statischen Dienstprogrammklasse aus zugänglich sein. Ich habe die Implementierung etwas geändert, damit die Methode als statisch deklariert werden kann. Es funktioniert genauso. Hier ist es:

/**
 * 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 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;
}
29
Lucio Paiva

Ich hatte dieses Problem oft selbst. Um Abhängigkeiten zu kleinen Projekten zu vermeiden, schreibe ich oft eine kleine Dienstprogrammfunktion, wenn ich keine Commons-Funktionen brauche. Hier ist Der Code zum Laden des Inhalts der Datei in einen Zeichenfolgenpuffer:

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

Die Angabe der Kodierung ist ist in diesem Fall wichtig, da Sie Ihre Datei in UTF-8 bearbeitet und dann in ein Glas gegeben haben. Der Computer, der Öffnet, hat möglicherweise CP- 1251 als native Dateikodierung (zum Beispiel); In In diesem Fall kennen Sie die Zielkodierung nie. Daher ist die explizite Kodierungsinformation Auch die Schleife zum Lesen der Datei char by char scheint ineffizient zu sein, wird jedoch auf einer BufferedReader, und so ziemlich schnell.

16
Harry Karadimas

Sie können den folgenden Code aus Java verwenden 

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

Wenn Sie Ihren String von einer Projektressource wie der Datei Testcase/foo.json in src/main/resources in Ihrem Projekt abrufen möchten, gehen Sie folgendermaßen vor:

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

Beachten Sie, dass die getClassLoader () -Methode in einigen anderen Beispielen fehlt.

4
Witbrock

Verwenden Sie die FileUtils von Apache Commons. Es hat eine Methode readFileToString

2
Suraj Chandran

Ich verwende Folgendes zum Lesen von Ressourcendateien aus der 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() : "";
        }
    }
}

Keine Abhängigkeiten von Drittanbietern erforderlich.

1
BullyWiiPlaza

Hier hat mein Ansatz gut funktioniert 

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

Wenn Sie Guava einschließen, können Sie Folgendes verwenden:

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

(Andere Lösungen erwähnten andere Methoden für Guava, die jedoch nicht mehr empfohlen werden.)

0
jolumg

Ich habe hier readResource () - Methoden geschrieben, um dies mit einem einfachen Aufruf tun zu können. Es hängt von der Guava-Bibliothek ab, aber ich mag nur in anderen Antworten vorgeschlagene JDK-Methoden, und ich denke, ich werde diese auf diese Weise ändern.

0
zakmck

Guava hat auch Files.readLines(), wenn Sie einen Rückgabewert als List<String> Zeile für Zeile erhalten möchten:

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

Unter hier finden Sie 3 Möglichkeiten (BufferedReader vs. Guava Files vs. Guava Resources), um String aus einer Textdatei zu erhalten.

0
philipjkim

Zumindest ab Apache commons-io 2.5 unterstützt die IOUtils.toString () - Methode ein URI-Argument und gibt den Inhalt von Dateien zurück, die sich innerhalb von jars im Klassenpfad befinden:

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

Mit einem Satz statischer Importe kann die Guava-Lösung sehr kompakt sein.

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

Folgende Importe sind erforderlich:

import static com.google.common.io.Resources.getResource
import static com.google.common.io.Resources.toString
import static Java.nio.charset.StandardCharsets.UTF_8
0
Michal Kordas