Utiles pour lire le fichier texte de ressource en chaîne (Java)
Existe-t-il un utilitaire permettant de lire un fichier texte de la ressource dans une chaîne. Je suppose que c’est une exigence populaire, mais je n’ai pas trouvé d’utilité après Google.
Vous pouvez utiliser l'ancien Stupid Scanner Astuce oneliner pour le faire sans dépendance supplémentaire comme la goyave:
String text = new Scanner(AppropriateClass.class.getResourceAsStream("foo.txt"), "UTF-8").useDelimiter("\\A").next();
Les gars, n'utilisez pas de trucs de tiers, sauf si vous en avez vraiment besoin. Il y a déjà beaucoup de fonctionnalités dans le JDK.
Pour Java 7:
new String(Files.readAllBytes(Paths.get(getClass().getResource("foo.txt").toURI())));
Guava a une méthode "toString" pour lire un fichier dans une chaîne:
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);
Cette méthode ne nécessite pas que le fichier soit dans le chemin de classe (comme dans Jon Skeet réponse précédente).
Apache-commons-io a un nom d’utilitaire FileUtils:
URL url = Resources.getResource("myFile.txt");
File myFile = new File(url.toURI());
String content = FileUtils.readFileToString(myFile, "UTF-8"); // or any other encoding
yegor256 a trouvé une solution intéressante avec Apache Commons IO :
import org.Apache.commons.io.IOUtils;
String text = IOUtils.toString(this.getClass().getResourceAsStream("foo.xml"),
"UTF-8");
Solution Java 8 pure et simple
Cette méthode simple ci-dessous fera très bien si vous utilisez 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;
}
Et cela fonctionne aussi avec les ressources dans les fichiers jar.
Il n'y a pas besoin de grosses bibliothèques. À moins que vous n'utilisiez déjà Guava ou Apache Commons IO, l'ajout de ces bibliothèques à votre projet simplement pour pouvoir lire un fichier en tant que chaîne semble un peu trop.
Chargement depuis un contexte statique
Comme il s'agit généralement d'une fonction utilitaire, on voudra probablement qu'elle soit accessible à partir d'une classe d'utilitaires statiques. J'ai un peu modifié l'implémentation pour pouvoir déclarer la méthode statique. Cela fonctionne quand même. C'est ici:
/**
* 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;
}
J'ai souvent eu ce problème moi-même. Pour éviter les dépendances sur de petits projets, j’écris souvent une petite fonction d’utilité quand je n’ai pas besoin de commons io ou autre. Voici le code pour charger le contenu du fichier dans un tampon de chaîne:
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());
Spécifier le codage est important dans ce cas, car vous pourriez avoir Édité votre fichier en UTF-8, puis mis dans un fichier jar, et l’ordinateur qui ouvre Le fichier peut avoir CP- 1251 comme encodage de fichier natif (par exemple); Ainsi, dans dans ce cas, vous ne connaissez jamais le codage cible. Par conséquent, les informations de codage explicites sont cruciales . La boucle permettant de lire le fichier char par char semble inefficace, mais elle est utilisée sur un. BufferedReader, et donc en fait assez rapide.
Vous pouvez utiliser le code Java suivant
new String(Files.readAllBytes(Paths.get(getClass().getResource("example.txt").toURI())));
Si vous souhaitez obtenir votre chaîne à partir d'une ressource de projet telle que le fichier Testcase/foo.json dans src/main/resources de votre projet, procédez comme suit:
String myString=
new String(Files.readAllBytes(Paths.get(getClass().getClassLoader().getResource("testcase/foo.json").toURI())));
Notez que la méthode getClassLoader () est manquante sur certains des autres exemples.
Utilisez FileUtils de Apache commons. Il a une méthode readFileToString
J'utilise ce qui suit pour lire les fichiers de ressources à partir 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() : "";
}
}
}
Aucune dépendance tierce requise.
Voici mon approche a bien fonctionné
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
}
}
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;
}
}
Si vous incluez la goyave, vous pouvez utiliser:
String fileContent= Files.asCharSource(new File(filename), Charset.forName("UTF-8")).read();
(D'autres solutions ont mentionné une autre méthode pour le goyave, mais elles sont déconseillées)
J'ai écrit les méthodes readResource () ici , pour pouvoir le faire en une simple invocation. Cela dépend de la bibliothèque Guava, mais j'aime bien les méthodes JDK uniquement suggérées dans d'autres réponses et je pense que je les changerai de cette façon.
Guava a également Files.readLines() si vous souhaitez une valeur de retour sous la forme List<String> ligne par ligne:
List<String> lines = Files.readLines(new File("/file/path/input.txt"), Charsets.UTF_8);
Veuillez vous référer à ici pour comparer 3 façons (BufferedReader contre Files de Guava contre Resources de Guava) pour obtenir String à partir d'un fichier texte.
Au moins depuis Apache commons-io 2.5, la méthode IOUtils.toString () prend en charge un argument URI et renvoie le contenu des fichiers situés dans des fichiers jar sur le chemin de classe:
IOUtils.toString(SomeClass.class.getResource(...).toURI(), ...)
Avec un ensemble d'importations statiques, la solution de goyave peut être très compacte:
toString(getResource("foo.txt"), UTF_8);
Les importations suivantes sont requises:
import static com.google.common.io.Resources.getResource
import static com.google.common.io.Resources.toString
import static Java.nio.charset.StandardCharsets.UTF_8