Java: Comment lire un fichier texte

Je veux lire un fichier texte contenant l'espace de valeurs séparées. Les valeurs sont des nombres entiers.
Comment puis-je le lire et de le mettre dans un tableau la liste?

Voici un exemple de contenu du fichier texte:

1 62 4 55 5 6 77

Je veux l'avoir dans une liste de tableaux comme [1, 62, 4, 55, 5, 6, 77]. Comment puis-je le faire en Java?

InformationsquelleAutor aks | 2010-05-07

170

Vous pouvez utiliser Fichiers#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"))) {
    //...
}
```
Tutoriel: E/S de base > Fichier I/O > de la Lecture, de l'Écriture et de Création de fichiers texte

Vous pouvez utiliser String#split() pour diviser un String dans les pièces en se basant sur une expression régulière.
```
for (String part : line.split("\\s+")) {
    //...
}
```
Tutoriel: Des nombres et des Chaînes > Cordes > Manipuler des Caractères dans une Chaîne

Vous pouvez utiliser Integer#valueOf() pour convertir un String dans un Integer.
```
Integer i = Integer.valueOf(part);
```
Tutoriel: Des nombres et des Chaînes > Cordes > la Conversion entre les Nombres et les Chaînes de caractères

Vous pouvez utiliser Liste#add() pour ajouter un élément à un List.
```
numbers.add(i);
```
Tutoriel: Interfaces > La Liste de l'Interface

Alors, en un mot (en supposant que le fichier ne possède pas de lignes vides, ni de fuite/leader des espaces).
```
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 arrive d'être à la Java 8 déjà, alors vous pouvez même utiliser Flux API pour cela, à commencer par Fichiers#lignes().
```
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 de données avec Java 8 flux
- Notez qu'il existe de meilleures façons de le faire en Java 7 et 8: stackoverflow.com/questions/4716503/...
InformationsquelleAutor BalusC
34

Java 1.5 introduit la Scanner classe pour la gestion des entrées à partir d'un fichier et de ruisseaux.

Il est utilisé pour obtenir des nombres entiers à partir d'un fichier et ressemblerait à quelque chose comme ceci:
```
List<Integer> integers = new ArrayList<Integer>();
Scanner fileScanner = new Scanner(new File("c:\\file.txt"));
while (fileScanner.hasNextInt()){
   integers.add(fileScanner.nextInt());
}
```
Vérifier l'API si. Il y a beaucoup plus d'options pour faire face aux différents types de sources d'entrée, différents délimiteurs, et les différents types de données.
- c'est de loin le plus facile à retenir que la mise en mémoire tampon, io, lecteur de combinaison
InformationsquelleAutor tschaible

Cet exemple de code montre comment lire le 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());                      
       }

     }
  }

InformationsquelleAutor Sajjad Khan

Oeil à cet exemple, et essayez de faire votre propre:

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

InformationsquelleAutor Eddinho

5

Juste pour le fun, voici ce que je ferais probablement dans un projet réel, où je suis déjà à l'aide de tous mes préférés bibliothèques (dans ce cas Goyave, anciennement connu sous le 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,cette). Modifier: Même s'il est intéressant de noter que dans ce cas tschaible du Scanner solution n'a plus de code!

Inconvénient: manifestement, vous ne voudrez pas ajouter de nouvelles dépendances de la bibliothèque juste pour cela. ^{(là encore, il serait bête de ne pas faire usage de Goyave dans vos projets. 😉}
- Bien sûr on peut aussi utiliser transform() & une Fonction de Google Collections à la place de la boucle, mais à mon humble avis ce serait moins lisible et pas encore plus courte.
InformationsquelleAutor Jonik

Utilisation Apache Commons (IO et Lang) pour une simple/commune des choses comme ça.

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

Fait.

InformationsquelleAutor Chris

À l'aide de Java 7 pour lire les fichiers avec NIO.2

Importer ces packages:

import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

C'est le processus de lecture d'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);

InformationsquelleAutor user2601995

1

Toutes les réponses jusqu'à présent compte tenu de la lecture du fichier ligne par ligne, en prenant la ligne en tant que String, puis le traitement de la String.

Il n'y a 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 va également être acceptable en termes d'efficacité. Mais si le fichier est long, c'est un moyen inefficace de le faire, pour deux raisons:
1. Chaque personnage est traité deux fois, une fois dans la construction de la String, et une fois dans son traitement.
2. Le garbage collector ne sera pas votre ami si il y a beaucoup de lignes dans le fichier. Vous êtes à la construction d'une nouvelle String pour chaque ligne, puis de le jeter quand vous passez à la ligne suivante. Le garbage collector finira par se débarrasser de tous ces String objets que vous ne voulez pas de plus. Quelqu'un a eu à nettoyer après vous.
Si vous vous souciez de vitesse, vous êtes beaucoup mieux de la lecture d'un bloc de données et le traitement octet par octet plutôt que ligne par ligne. Chaque fois que vous arrivez à la fin d'un nombre, vous l'ajouter à la List vous êtes en train de construire.

Il va sortir 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 que c'est le code ASCII (bien qu'il peut être facilement modifié pour d'autres codages), et que tout ce qui n'est pas un chiffre (en particulier, un espace ou un saut de ligne) représente une frontière entre les chiffres. Il suppose également que le fichier se termine par un chiffre (dans la pratique, que la dernière ligne se termine par un saut de ligne), même si encore une fois, il pourrait être modifié pour traiter le cas où il ne l'est pas.

C'est beaucoup, beaucoup plus rapide que tout le Stringbasée sur des approches aussi étant donné que les réponses à cette question. Il y a une enquête détaillée de la très semblable à la question dans cette question. Vous allez voir qu'il y a la possibilité de l'améliorer encore plus loin si vous voulez aller en bas de la multi-thread ligne.

InformationsquelleAutor chiastic-security
0

lire le fichier, puis faire ce que vous voulez
java8
Les fichiers.lignes(les Chemins d'accès.get("c://lines.txt")).recueillir des(Collectionneurs.toList());

InformationsquelleAutor Ran Adler

Vous devez vous connecter pour publier un commentaire.