Java: Comment lire un fichier texte
Je veux lire un fichier texte contenant des valeurs séparées par des espaces. Les valeurs sont des entiers. Comment puis-je le lire et le mettre dans une liste de tableau?
Voici un exemple de contenu du fichier texte:
1 62 4 55 5 6 77
Je veux l'avoir dans un répertoire en tant que [1, 62, 4, 55, 5, 6, 77]. Comment puis-je le faire en Java?
Vous pouvez utiliser Files#readAllLines() pour obtenir toutes les lignes d'un fichier texte dans un List<String>.
for (String line : Files.readAllLines(Paths.get("/path/to/file.txt"))) {
// ...
}
Didacticiel: E/S de base> E/S de fichier> Lecture, écriture et création de fichiers texte
Vous pouvez utiliser String#split() pour scinder un String en parties en fonction d'une expression régulière.
for (String part : line.split("\\s+")) {
// ...
}
Didacticiel: Nombres et chaînes> Chaînes> Manipulation de caractères dans une chaîne
Vous pouvez utiliser Integer#valueOf() pour convertir un String en un Integer.
Integer i = Integer.valueOf(part);
Didacticiel: Nombres et chaînes> Chaînes> Conversion entre nombres et chaînes
Vous pouvez utiliser List#add() pour ajouter un élément à un List.
numbers.add(i);
Didacticiel: interfaces> l'interface de liste
Donc, en un mot (en supposant que le fichier ne comporte pas de lignes vides ni d'espaces de fin/septième).
List<Integer> numbers = new ArrayList<>();
for (String line : Files.readAllLines(Paths.get("/path/to/file.txt"))) {
for (String part : line.split("\\s+")) {
Integer i = Integer.valueOf(part);
numbers.add(i);
}
}
Si vous vous trouvez déjà à Java 8, vous pouvez même utiliser Stream API pour cela, en commençant par Files#lines() .
List<Integer> numbers = Files.lines(Paths.get("/path/to/test.txt"))
.map(line -> line.split("\\s+")).flatMap(Arrays::stream)
.map(Integer::valueOf)
.collect(Collectors.toList());
Tutoriel: Traitement des données avec Java 8 flux
Java 1.5 a introduit la classe Scanner pour la gestion des entrées à partir de fichiers et de flux.
Il est utilisé pour obtenir des entiers à partir d'un fichier et ressemblerait à ceci:
List<Integer> integers = new ArrayList<Integer>();
Scanner fileScanner = new Scanner(new File("c:\\file.txt"));
while (fileScanner.hasNextInt()){
integers.add(fileScanner.nextInt());
}
Vérifiez l'API cependant. Il existe beaucoup plus d'options pour gérer différents types de sources d'entrée, différents délimiteurs et différents types de données.
Cet exemple de code vous montre comment lire un fichier en Java.
import Java.io.*;
/**
* This example code shows you how to read file in Java
*
* IN MY CASE RAILWAY IS MY TEXT FILE WHICH I WANT TO DISPLAY YOU CHANGE WITH YOUR OWN
*/
public class ReadFileExample
{
public static void main(String[] args)
{
System.out.println("Reading File from Java code");
//Name of the file
String fileName="RAILWAY.txt";
try{
//Create object of FileReader
FileReader inputFile = new FileReader(fileName);
//Instantiate the BufferedReader Class
BufferedReader bufferReader = new BufferedReader(inputFile);
//Variable to hold the one line data
String line;
// Read file line by line and print on the console
while ((line = bufferReader.readLine()) != null) {
System.out.println(line);
}
//Close the buffer reader
bufferReader.close();
}catch(Exception e){
System.out.println("Error while reading file line by line:" + e.getMessage());
}
}
}
Regardez cet exemple et essayez de faire le vôtre:
import Java.io.*;
public class ReadFile {
public static void main(String[] args){
String string = "";
String file = "textFile.txt";
// Reading
try{
InputStream ips = new FileInputStream(file);
InputStreamReader ipsr = new InputStreamReader(ips);
BufferedReader br = new BufferedReader(ipsr);
String line;
while ((line = br.readLine()) != null){
System.out.println(line);
string += line + "\n";
}
br.close();
}
catch (Exception e){
System.out.println(e.toString());
}
// Writing
try {
FileWriter fw = new FileWriter (file);
BufferedWriter bw = new BufferedWriter (fw);
PrintWriter fileOut = new PrintWriter (bw);
fileOut.println (string+"\n test of read and write !!");
fileOut.close();
System.out.println("the file " + file + " is created!");
}
catch (Exception e){
System.out.println(e.toString());
}
}
}
Juste pour le plaisir, voici ce que je ferais probablement dans un vrai projet, où j'utilise déjà toutes mes bibliothèques préférées (dans ce cas Guava ) ==, anciennement appelé Google Collections ).
String text = Files.toString(new File("textfile.txt"), Charsets.UTF_8);
List<Integer> list = Lists.newArrayList();
for (String s : text.split("\\s")) {
list.add(Integer.valueOf(s));
}
Avantage: Pas beaucoup de code à maintenir (contraste avec, par exemple, this ). Edit : Bien qu'il soit intéressant de noter que dans ce cas la solution de scanner de tschaible n'a plus de code!
Inconvénient: vous pouvez évidemment ne pas vouloir ajouter de nouvelles dépendances de bibliothèque uniquement pour cela. (Encore une fois, vous seriez stupide de ne pas utiliser Guava dans vos projets. ;-)
Utilisez Apache Commons (IO et Lang) pour des choses simples/communes comme celle-ci.
Importations:
import org.Apache.commons.io.FileUtils;
import org.Apache.commons.lang3.ArrayUtils;
Code:
String contents = FileUtils.readFileToString(new File("path/to/your/file.txt"));
String[] array = ArrayUtils.toArray(contents.split(" "));
Terminé.
Utilisation de Java 7 pour lire des fichiers avec NIO.2
Importez ces paquets:
import Java.nio.charset.Charset;
import Java.nio.file.Files;
import Java.nio.file.Path;
import Java.nio.file.Paths;
C'est le processus pour lire un fichier:
Path file = Paths.get("C:\\Java\\file.txt");
if(Files.exists(file) && Files.isReadable(file)) {
try {
// File reader
BufferedReader reader = Files.newBufferedReader(file, Charset.defaultCharset());
String line;
// read each line
while((line = reader.readLine()) != null) {
System.out.println(line);
// tokenize each number
StringTokenizer tokenizer = new StringTokenizer(line, " ");
while (tokenizer.hasMoreElements()) {
// parse each integer in file
int element = Integer.parseInt(tokenizer.nextToken());
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
}
Pour lire toutes les lignes d’un fichier à la fois:
Path file = Paths.get("C:\\Java\\file.txt");
List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);
Toutes les réponses données jusqu'ici impliquent de lire le fichier ligne par ligne, en prenant la ligne comme un String, puis en traitant le String.
Il ne fait aucun doute que c’est l’approche la plus facile à comprendre, et si le fichier est assez court (par exemple, des dizaines de milliers de lignes), il sera également acceptable en termes d’efficacité. Mais si le fichier est long , c'est une façon très inefficace de le faire, pour deux raisons:
- Chaque caractère est traité deux fois, une fois lors de la construction de
Stringet une fois lors de son traitement. - Le ramasse-miettes ne sera pas votre ami s'il y a beaucoup de lignes dans le fichier. Vous construisez une nouvelle
Stringpour chaque ligne, puis vous la jetez lorsque vous passez à la ligne suivante. Le ramasse-miettes devra éventuellement disposer de tous ces objetsStringdont vous ne voulez plus. Quelqu'un doit nettoyer après toi.
Si la vitesse vous tient à cœur, il vaut mieux lire un bloc de données puis le traiter octet par octet plutôt que ligne par ligne. Chaque fois que vous arrivez à la fin d'un nombre, vous l'ajoutez à la List que vous construisez.
Il en sortira quelque chose comme ceci:
private List<Integer> readIntegers(File file) throws IOException {
List<Integer> result = new ArrayList<>();
RandomAccessFile raf = new RandomAccessFile(file, "r");
byte buf[] = new byte[16 * 1024];
final FileChannel ch = raf.getChannel();
int fileLength = (int) ch.size();
final MappedByteBuffer mb = ch.map(FileChannel.MapMode.READ_ONLY, 0,
fileLength);
int acc = 0;
while (mb.hasRemaining()) {
int len = Math.min(mb.remaining(), buf.length);
mb.get(buf, 0, len);
for (int i = 0; i < len; i++)
if ((buf[i] >= 48) && (buf[i] <= 57))
acc = acc * 10 + buf[i] - 48;
else {
result.add(acc);
acc = 0;
}
}
ch.close();
raf.close();
return result;
}
Le code ci-dessus suppose qu'il s'agit de ASCII (bien qu'il puisse être facilement modifié pour d'autres codages), et que tout ce qui n'est pas un chiffre (en particulier un espace ou une nouvelle ligne) représente une limite entre les chiffres. . Cela suppose également que le fichier se termine par un chiffre non numérique (en pratique, la dernière ligne se termine par un retour à la ligne), bien que, là encore, il puisse être modifié pour traiter le cas où ce n'est pas le cas.
C'est beaucoup, beaucoup plus rapide que toutes les approches basées sur String- également données en réponse à cette question. Il existe une enquête détaillée sur un problème très similaire dans cette question . Vous verrez qu'il y a la possibilité de l'améliorer encore si vous voulez descendre la ligne multi-thread.
lisez le fichier puis faites ce que vous voulez. Java8 Files.lines (Paths.get ("c: //lines.txt")). collect (Collectors.toList ());