Lecture d'un fichier texte brut dans Java
Il semble qu'il existe différentes manières de lire et d'écrire des données de fichiers en Java.
Je veux lire les données ASCII d'un fichier. Quels sont les moyens possibles et leurs différences?
ASCII est un fichier texte. Vous devez donc utiliser Readers pour la lecture. Java prend également en charge la lecture d'un fichier binaire à l'aide de InputStreams . Si les fichiers en cours de lecture sont énormes, vous voudrez utiliser un BufferedReader par-dessus un FileReader pour améliorer les performances de lecture.
Parcourez cet article sur l'utilisation d'un Reader
Je vous recommande également de télécharger et de lire ce livre merveilleux (et pourtant gratuit) intitulé Thinking In Java
Dans Java 7 :
new String(Files.readAllBytes(...))
(docs) ou
Files.readAllLines(...)
Dans Java 8 :
Files.lines(..).forEach(...)
Ma façon préférée de lire un petit fichier est d’utiliser BufferedReader et StringBuilder. C'est très simple et précis (mais pas particulièrement efficace, mais suffisant dans la plupart des cas):
BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
String everything = sb.toString();
} finally {
br.close();
}
Certains ont fait remarquer qu'après Java 7, vous devriez utiliser les fonctionnalités try-with-resources (c'est-à-dire la fermeture automatique):
try(BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
String everything = sb.toString();
}
Quand je lis des chaînes comme celle-ci, je veux de toute façon faire quelques manipulations de chaîne par ligne, alors je choisis cette implémentation.
Cependant, si je veux simplement lire un fichier dans une chaîne, j'utilise toujours Apache Commons IO avec la méthode IOUtils.toString () de classe. Vous pouvez consulter la source ici:
http://www.docjar.com/html/api/org/Apache/commons/io/IOUtils.Java.html
FileInputStream inputStream = new FileInputStream("foo.txt");
try {
String everything = IOUtils.toString(inputStream);
} finally {
inputStream.close();
}
Et encore plus simple avec Java 7:
try(FileInputStream inputStream = new FileInputStream("foo.txt")) {
String everything = IOUtils.toString(inputStream);
// do something with everything string
}
Le moyen le plus simple consiste à utiliser la classe Scanner dans Java et l'objet FileReader. Exemple simple:
Scanner in = new Scanner(new FileReader("filename.txt"));
Scanner dispose de plusieurs méthodes pour lire des chaînes, des nombres, etc. Vous pouvez trouver plus d'informations à ce sujet sur la page de documentation Java.
Par exemple, lire tout le contenu dans un String:
StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
sb.append(in.next());
}
in.close();
outString = sb.toString();
Aussi, si vous avez besoin d'un encodage spécifique, vous pouvez utiliser ceci à la place de FileReader:
new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)
Voici une solution simple:
String content;
content = new String(Files.readAllBytes(Paths.get("sample.txt")));
Voici une autre façon de le faire sans utiliser de bibliothèques externes:
import Java.io.File;
import Java.io.FileReader;
import Java.io.IOException;
public String readFile(String filename)
{
String content = null;
File file = new File(filename); // For example, foo.txt
FileReader reader = null;
try {
reader = new FileReader(file);
char[] chars = new char[(int) file.length()];
reader.read(chars);
content = new String(chars);
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(reader != null){
reader.close();
}
}
return content;
}
Je devais comparer les différentes manières. Je commenterai mes conclusions mais, en bref, le moyen le plus rapide consiste à utiliser un ancien BufferedInputStream vierge par rapport à un FileInputStream. Si de nombreux fichiers doivent être lus, trois threads réduiront le temps d'exécution total d'environ la moitié, mais l'ajout de plusieurs threads dégradera progressivement les performances jusqu'à ce qu'il soit trois fois plus long à terminer avec vingt threads qu'avec un seul thread.
L'hypothèse est que vous devez lire un fichier et faire quelque chose de significatif avec son contenu. Dans les exemples, lisez les lignes d’un journal et comptez celles qui contiennent des valeurs dépassant un certain seuil. Je suppose donc que le one-liner Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) n'est pas une option.
J'ai testé sur Java 1.8, Windows 7 et les lecteurs SSD et HDD.
J'ai écrit six implémentations différentes:
rawParse : Utilisez BufferedInputStream sur un FileInputStream, puis coupez les lignes lisant octet par octet. Cela surpasse toute autre approche mono-thread, mais cela peut être très gênant pour les fichiers non-ASCII.
lineReaderParse : Utilisez un BufferedReader sur un FileReader, lisez ligne par ligne, divisez les lignes en appelant String.split (). Ceci est approximativement 20% plus lent que rawParse.
lineReaderParseParallel : Identique à lineReaderParse, mais utilise plusieurs threads. C’est l’option la plus rapide dans tous les cas.
nioFilesParse : utilisez Java.nio.files.Files.lines ()
nioAsyncParse : utilisez un fichier AsynchronousFileChannel avec un gestionnaire d'achèvement et un pool de threads.
nioMemoryMappedParse : utilise un fichier mappé en mémoire. C'est vraiment une mauvaise idée de donner des temps d'exécution au moins trois fois plus longs que toute autre implémentation.
Ce sont les temps moyens de lecture de 204 fichiers de 4 Mo chacun sur un lecteur quadri-core i7 et SSD. Les fichiers sont générés à la volée pour éviter la mise en cache du disque.
rawParse 11.10 sec
lineReaderParse 13.86 sec
lineReaderParseParallel 6.00 sec
nioFilesParse 13.52 sec
nioAsyncParse 16.06 sec
nioMemoryMappedParse 37.68 sec
J'ai trouvé une différence plus petite que prévue entre une exécution sur un SSD ou un lecteur de disque dur, le SSD étant environ 15% plus rapide. Cela peut être dû au fait que les fichiers sont générés sur un disque dur non fragmenté et lus de manière séquentielle. Par conséquent, le lecteur en rotation peut fonctionner presque comme un disque SSD.
J'ai été surpris par les faibles performances de l'implémentation nioAsyncParse. Soit j'ai implémenté quelque chose de mal, soit l'implémentation multithread à l'aide de NIO et un gestionnaire d'achèvement fonctionne de la même manière (voire pire) qu'une implémentation à un seul thread avec l'API Java.io. De plus, l'analyse asynchrone avec un CompletionHandler est beaucoup plus longue dans les lignes de code et difficile à implémenter correctement qu'une implémentation directe sur d'anciens flux.
Maintenant, les six implémentations suivies par une classe les contenant toutes, plus une méthode paramétrable main () qui permet de jouer avec le nombre de fichiers, la taille du fichier et le degré de simultanéité. Notez que la taille des fichiers varie de plus 20%. Cela évite tout effet car tous les fichiers ont exactement la même taille.
rawParse
public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
overrunCount = 0;
final int dl = (int) ';';
StringBuffer lineBuffer = new StringBuffer(1024);
for (int f=0; f<numberOfFiles; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
FileInputStream fin = new FileInputStream(fl);
BufferedInputStream bin = new BufferedInputStream(fin);
int character;
while((character=bin.read())!=-1) {
if (character==dl) {
// Here is where something is done with each line
doSomethingWithRawLine(lineBuffer.toString());
lineBuffer.setLength(0);
}
else {
lineBuffer.append((char) character);
}
}
bin.close();
fin.close();
}
}
public final void doSomethingWithRawLine(String line) throws ParseException {
// What to do for each line
int fieldNumber = 0;
final int len = line.length();
StringBuffer fieldBuffer = new StringBuffer(256);
for (int charPos=0; charPos<len; charPos++) {
char c = line.charAt(charPos);
if (c==DL0) {
String fieldValue = fieldBuffer.toString();
if (fieldValue.length()>0) {
switch (fieldNumber) {
case 0:
Date dt = fmt.parse(fieldValue);
fieldNumber++;
break;
case 1:
double d = Double.parseDouble(fieldValue);
fieldNumber++;
break;
case 2:
int t = Integer.parseInt(fieldValue);
fieldNumber++;
break;
case 3:
if (fieldValue.equals("overrun"))
overrunCount++;
break;
}
}
fieldBuffer.setLength(0);
}
else {
fieldBuffer.append(c);
}
}
}
lineReaderParse
public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
String line;
for (int f=0; f<numberOfFiles; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
FileReader frd = new FileReader(fl);
BufferedReader brd = new BufferedReader(frd);
while ((line=brd.readLine())!=null)
doSomethingWithLine(line);
brd.close();
frd.close();
}
}
public final void doSomethingWithLine(String line) throws ParseException {
// Example of what to do for each line
String[] fields = line.split(";");
Date dt = fmt.parse(fields[0]);
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCount++;
}
lineReaderParseParallel
public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
Thread[] pool = new Thread[degreeOfParalelism];
int batchSize = numberOfFiles / degreeOfParalelism;
for (int b=0; b<degreeOfParalelism; b++) {
pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
pool[b].start();
}
for (int b=0; b<degreeOfParalelism; b++)
pool[b].join();
}
class LineReaderParseThread extends Thread {
private String targetDir;
private int fileFrom;
private int fileTo;
private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
private int overrunCounter = 0;
public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
this.targetDir = targetDir;
this.fileFrom = fileFrom;
this.fileTo = fileTo;
}
private void doSomethingWithTheLine(String line) throws ParseException {
String[] fields = line.split(DL);
Date dt = fmt.parse(fields[0]);
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCounter++;
}
@Override
public void run() {
String line;
for (int f=fileFrom; f<fileTo; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
try {
FileReader frd = new FileReader(fl);
BufferedReader brd = new BufferedReader(frd);
while ((line=brd.readLine())!=null) {
doSomethingWithTheLine(line);
}
brd.close();
frd.close();
} catch (IOException | ParseException ioe) { }
}
}
}
nioFilesParse
public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
for (int f=0; f<numberOfFiles; f++) {
Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
Consumer<String> action = new LineConsumer();
Stream<String> lines = Files.lines(ph);
lines.forEach(action);
lines.close();
}
}
class LineConsumer implements Consumer<String> {
@Override
public void accept(String line) {
// What to do for each line
String[] fields = line.split(DL);
if (fields.length>1) {
try {
Date dt = fmt.parse(fields[0]);
}
catch (ParseException e) {
}
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCount++;
}
}
}
nioAsyncParse
public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<ByteBuffer>();
for (int b=0; b<numberOfThreads; b++)
byteBuffers.add(ByteBuffer.allocate(bufferSize));
for (int f=0; f<numberOfFiles; f++) {
consumerThreads.acquire();
String fileName = targetDir+filenamePreffix+String.valueOf(f)+".txt";
AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(fileName), EnumSet.of(StandardOpenOption.READ), pool);
BufferConsumer consumer = new BufferConsumer(byteBuffers, fileName, bufferSize);
channel.read(consumer.buffer(), 0l, channel, consumer);
}
consumerThreads.acquire(numberOfThreads);
}
class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {
private ConcurrentLinkedQueue<ByteBuffer> buffers;
private ByteBuffer bytes;
private String file;
private StringBuffer chars;
private int limit;
private long position;
private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
buffers = byteBuffers;
bytes = buffers.poll();
if (bytes==null)
bytes = ByteBuffer.allocate(bufferSize);
file = fileName;
chars = new StringBuffer(bufferSize);
frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
limit = bufferSize;
position = 0l;
}
public ByteBuffer buffer() {
return bytes;
}
@Override
public synchronized void completed(Integer result, AsynchronousFileChannel channel) {
if (result!=-1) {
bytes.flip();
final int len = bytes.limit();
int i = 0;
try {
for (i = 0; i < len; i++) {
byte by = bytes.get();
if (by=='\n') {
// ***
// The code used to process the line goes here
chars.setLength(0);
}
else {
chars.append((char) by);
}
}
}
catch (Exception x) {
System.out.println(
"Caught exception " + x.getClass().getName() + " " + x.getMessage() +
" i=" + String.valueOf(i) + ", limit=" + String.valueOf(len) +
", position="+String.valueOf(position));
}
if (len==limit) {
bytes.clear();
position += len;
channel.read(bytes, position, channel, this);
}
else {
try {
channel.close();
}
catch (IOException e) {
}
consumerThreads.release();
bytes.clear();
buffers.add(bytes);
}
}
else {
try {
channel.close();
}
catch (IOException e) {
}
consumerThreads.release();
bytes.clear();
buffers.add(bytes);
}
}
@Override
public void failed(Throwable e, AsynchronousFileChannel channel) {
}
};
MISE EN ŒUVRE PLEINE EXÉCUTABLE DE TOUS LES CAS
https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.Java
Voici les trois méthodes de travail et testées:
Utiliser BufferedReader
package io;
import Java.io.*;
public class ReadFromFile2 {
public static void main(String[] args)throws Exception {
File file = new File("C:\\Users\\pankaj\\Desktop\\test.Java");
BufferedReader br = new BufferedReader(new FileReader(file));
String st;
while((st=br.readLine()) != null){
System.out.println(st);
}
}
}
Utiliser Scanner
package io;
import Java.io.File;
import Java.util.Scanner;
public class ReadFromFileUsingScanner {
public static void main(String[] args) throws Exception {
File file = new File("C:\\Users\\pankaj\\Desktop\\test.Java");
Scanner sc = new Scanner(file);
while(sc.hasNextLine()){
System.out.println(sc.nextLine());
}
}
}
Utiliser FileReader
package io;
import Java.io.*;
public class ReadingFromFile {
public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("C:\\Users\\pankaj\\Desktop\\test.Java");
int i;
while ((i=fr.read()) != -1){
System.out.print((char) i);
}
}
}
Lire le fichier entier sans boucle à l'aide de la classe Scanner
package io;
import Java.io.File;
import Java.io.FileNotFoundException;
import Java.util.Scanner;
public class ReadingEntireFileWithoutLoop {
public static void main(String[] args) throws FileNotFoundException {
File file = new File("C:\\Users\\pankaj\\Desktop\\test.Java");
Scanner sc = new Scanner(file);
sc.useDelimiter("\\Z");
System.out.println(sc.next());
}
}
Les méthodes à l'intérieur de org.Apache.commons.io.FileUtils peuvent également être très pratiques, par exemple:
_/**
* Reads the contents of a file line by line to a List
* of Strings using the default encoding for the VM.
*/
static List readLines(File file)
_Que voulez-vous faire avec le texte? Le fichier est-il assez petit pour tenir dans la mémoire? Je voudrais essayer de trouver le moyen le plus simple de gérer le fichier pour vos besoins. La bibliothèque FileUtils est très utile pour cela.
for(String line: FileUtils.readLines("my-text-file"))
System.out.println(line);
J'ai documenté 15 façons de lire un fichier en Java et les ai ensuite testés pour leur vitesse avec différentes tailles de fichiers - de 1 Ko à 1 Go. Voici les trois meilleures façons de le faire:
Java.nio.file.Files.readAllBytes()Testé pour fonctionner dans Java 7, 8 et 9.
import Java.io.File; import Java.io.IOException; import Java.nio.file.Files; public class ReadFile_Files_ReadAllBytes { public static void main(String [] pArgs) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; File file = new File(fileName); byte [] fileBytes = Files.readAllBytes(file.toPath()); char singleChar; for(byte b : fileBytes) { singleChar = (char) b; System.out.print(singleChar); } } }Java.io.BufferedReader.readLine()Testé pour fonctionner dans Java 7, 8, 9.
import Java.io.BufferedReader; import Java.io.FileReader; import Java.io.IOException; public class ReadFile_BufferedReader_ReadLine { public static void main(String [] args) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; FileReader fileReader = new FileReader(fileName); try (BufferedReader bufferedReader = new BufferedReader(fileReader)) { String line; while((line = bufferedReader.readLine()) != null) { System.out.println(line); } } } }Java.nio.file.Files.lines()Cela a été testé pour fonctionner dans Java 8 et 9 mais ne fonctionnera pas dans Java 7 en raison de la nécessité de l'expression lambda.
import Java.io.File; import Java.io.IOException; import Java.nio.file.Files; import Java.util.stream.Stream; public class ReadFile_Files_Lines { public static void main(String[] pArgs) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; File file = new File(fileName); try (Stream linesStream = Files.lines(file.toPath())) { linesStream.forEach(line -> { System.out.println(line); }); } } }
Vous trouverez ci-dessous une procédure à suivre dans le sens Java 8. En supposant que le fichier text.txt se trouve à la racine du répertoire de projet de Eclipse.
Files.lines(Paths.get("text.txt")).collect(Collectors.toList());
C'est fondamentalement la même chose que la réponse de Jesus Ramos, sauf que Fichier au lieu de FileReader plus une itération pour parcourir le contenu du fichier.
Scanner in = new Scanner(new File("filename.txt"));
while (in.hasNext()) { // Iterates each line in the file
String line = in.nextLine();
// Do something with line
}
in.close(); // Don't forget to close resource leaks
... jette FileNotFoundException
Utilisation de BufferedReader:
import Java.io.BufferedReader;
import Java.io.FileNotFoundException;
import Java.io.FileReader;
import Java.io.IOException;
BufferedReader br;
try {
br = new BufferedReader(new FileReader("/fileToRead.txt"));
try {
String x;
while ( (x = br.readLine()) != null ) {
// Printing out each line in the file
System.out.println(x);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
catch (FileNotFoundException e) {
System.out.println(e);
e.printStackTrace();
}
Probablement pas aussi vite qu'avec les entrées/sorties tamponnées, mais plutôt laconique:
String content;
try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
content = scanner.next();
}
Le modèle \Z indique à la Scanner que le délimiteur est EOF.
Les classes de flux en mémoire tampon sont beaucoup plus performantes dans la pratique, de sorte que l'API NIO.2 inclut des méthodes qui renvoient spécifiquement ces classes de flux, en partie pour vous encourager à toujours utiliser des flux en mémoire tampon dans votre application.
Voici un exemple:
Path path = Paths.get("/myfolder/myfile.ext");
try (BufferedReader reader = Files.newBufferedReader(path)) {
// Read from the stream
String currentLine = null;
while ((currentLine = reader.readLine()) != null)
//do your code here
} catch (IOException e) {
// Handle file I/O exception...
}
Vous pouvez remplacer ce code
BufferedReader reader = Files.newBufferedReader(path);
avec
BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));
Je recommande this article d’apprendre les principales utilisations de Java NIO et IO.
Je ne le vois pas encore mentionné dans les autres réponses jusqu'à présent. Mais si "Meilleur" signifie vitesse, le nouveau Java I/O (NIO) peut fournir la performance la plus rapide, mais pas toujours la plus facile à comprendre pour un apprenant.
http://download.Oracle.com/javase/tutorial/essential/io/file.html
Le moyen le plus simple de lire les données d’un fichier dans Java consiste à utiliser la classe Fichier pour lire le fichier et la classe Scanner contenu du fichier.
public static void main(String args[])throws Exception
{
File f = new File("input.txt");
takeInputIn2DArray(f);
}
public static void takeInputIn2DArray(File f) throws Exception
{
Scanner s = new Scanner(f);
int a[][] = new int[20][20];
for(int i=0; i<20; i++)
{
for(int j=0; j<20; j++)
{
a[i][j] = s.nextInt();
}
}
}
PS: N'oubliez pas d'importer Java.util. *; pour que le scanner fonctionne.
Cela pourrait ne pas être la réponse exacte à la question. C'est juste une autre façon de lire un fichier où vous ne spécifiez pas explicitement le chemin d'accès à votre fichier dans votre code Java, mais vous le lisez plutôt comme un argument de ligne de commande.
Avec le code suivant,
import Java.io.BufferedReader;
import Java.io.InputStreamReader;
import Java.io.IOException;
public class InputReader{
public static void main(String[] args)throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s="";
while((s=br.readLine())!=null){
System.out.println(s);
}
}
}
allez-y et lancez-le avec:
Java InputReader < input.txt
Cela lirait le contenu du input.txt et l'imprimerait sur votre console.
Vous pouvez également demander à votre System.out.println() d'écrire dans un fichier spécifique via la ligne de commande, comme suit:
Java InputReader < input.txt > output.txt
Ceci lirait de input.txt et écrirait à output.txt.
Guava fournit un one-liner pour cela:
import com.google.common.base.Charsets;
import com.google.common.io.Files;
String contents = Files.toString(filePath, Charsets.UTF_8);
Vous pouvez utiliser readAllLines et la méthode join pour obtenir le contenu intégral d'un fichier sur une seule ligne:
String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));
Il utilise le codage UTF-8 par défaut, qui lit correctement les données ASCII.
Aussi, vous pouvez utiliser readAllBytes:
String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);
Je pense que readAllBytes est plus rapide et plus précis, car il ne remplace pas la nouvelle ligne par \n et la nouvelle ligne peut également être \r\n. C'est en fonction de vos besoins lequel vous convient.
Cactoos vous donne un one-liner déclaratif:
new TextOf(new File("a.txt")).asString();
Pour les applications Web Maven basées sur JSF, utilisez simplement ClassLoader et le dossier Resources pour lire le fichier souhaité:
- Placez tout fichier que vous voulez lire dans le dossier Ressources.
Mettez la dépendance Apache Commons IO dans votre POM:
<dependency> <groupId>org.Apache.commons</groupId> <artifactId>commons-io</artifactId> <version>1.3.2</version> </dependency>Utilisez le code ci-dessous pour le lire (par exemple, ci-dessous se lit dans un fichier .json):
String metadata = null; FileInputStream inputStream; try { ClassLoader loader = Thread.currentThread().getContextClassLoader(); inputStream = (FileInputStream) loader .getResourceAsStream("/metadata.json"); metadata = IOUtils.toString(inputStream); inputStream.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return metadata;
Vous pouvez faire la même chose pour les fichiers texte, les fichiers .properties, les schémas XSD , etc.
Utilisez Java kiss s'il s'agit de la simplicité de la structure:
import static kiss.API.*;
class App {
void run() {
String line;
try (Close in = inOpen("file.dat")) {
while ((line = readLine()) != null) {
println(line);
}
}
}
}