TOC

Lire un fichier dans une liste de tableaux

Lire un fichier dans une liste de tableaux

1. Vue d'ensemble

Dans ce didacticiel, nous aborderonsdifferent ways of reading a file into an ArrayList.

Il existe de nombreuses façons deread a file in Java. Une fois que nous lisons un fichier, nous pouvons effectuer de nombreuses opérations sur le contenu de ce fichier.

Certaines de ces opérations, telles que le tri, peuvent nécessiter le traitement de la totalité du contenu du fichier. Afin d'effectuer de telles opérations, nous pouvons avoir besoin de lire le fichier comme unArray ou unList de lignes ou de mots.

2. Utilisation deFileReader

Le moyen le plus simple de lire un fichier en Java est d'utiliserFileReader. Par définition,FileReader is a convenience class for reading stream of characters from a File.

Il existe plusieurs constructeurs disponibles pour initialiser unFileReader: 

FileReader f = new FileReader(String filepath);
FileReader f = new FileReader(File f);
FileReader f = new FileReader(FileDescriptor fd);

Tous ces constructeurs supposent que l'encodage de caractères par défaut et la taille de tampon d'octets par défaut sont appropriés.

Cependant, si nous voulons fournir un encodage de caractères personnalisé et une taille de tampon d'octets, nous pouvons utiliserInputStreamReader ouFileInputStream.

Dans le code suivant, nous allons montrer comment lire des lignes d'un fichier dans unArrayList, en utilisantFileReader: 

ArrayList result = new ArrayList<>();

try (FileReader f = new FileReader(filename)) {
    StringBuffer sb = new StringBuffer();
    while (f.ready()) {
        char c = (char) f.read();
        if (c == '\n') {
            result.add(sb.toString());
            sb = new StringBuffer();
        } else {
            sb.append(c);
        }
    }
    if (sb.length() > 0) {
        result.add(sb.toString());
    }
}
return result;

3. Utilisation deBufferedReader

Bien queFileReader soit assez facile à utiliser, il est conseillé de toujours l'encapsuler avecBuffereReader, lors de la lecture d'un fichier.

Ceci est dû au fait queBufferedReader uses a char buffer to simultaneously read multiple values from a character-input stream and réduit donc le nombre d'appelsread() effectués par lesFileStream sous-jacents.

Les constructeurs pourBufferedReader prennentReader comme entrée. De plus, nous pouvons également fournir une taille de tampon dans les constructeurs, mais dans la plupart des cas d'utilisation, la taille par défaut est suffisamment grande: 

BufferedReader br = new BufferedReader(new FileReader(filename));
BufferedReader br = new BufferedReader(new FileReader(filename), size);

En plus des méthodes héritées de la classeReader,BufferedReader also provide la méthodereadLine(), pour lire une ligne entière en tant queString: 

ArrayList result = new ArrayList<>();

try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
    while (br.ready()) {
        result.add(br.readLine());
    }
}

4. Utilisation deScanner

Une autre façon courante de lire des fichiers consiste à utiliserScanner.

Scanner est un simple scanner de texte, utilisé pour analyser les types primitifs et les chaînes, en utilisant des expressions régulières.

Lors de la lecture de fichiers,Scanner est initialisé à l'aide des objetsFile ouFileReader: 

Scanner s = new Scanner(new File(filename));
Scanner s = new Scanner(new FileReader(filename));

Similaire àBufferedReader, Scanner fournit la méthodereadLine() pour lire une ligne entière. De plus,, it fournit également une méthodehasNext() pour indiquer si plus de valeurs sont disponibles pour la lecture ou non : 

ArrayList result = new ArrayList<>();

try (Scanner s = new Scanner(new FileReader(filename))) {
    while (s.hasNext()) {
        result.add(s.nextLine());
    }
    return result;
}

Scanner divise son entrée en jetons en utilisant un délimiteur, le délimiteur par défaut étant un espace blanc. Ces jetons peuvent être convertis en valeurs de différents types, en utilisant diverses méthodesnext  (nextInt,nextLong, etc.) disponibles: 

ArrayList result = new ArrayList<>();

try (Scanner s = new Scanner(new FileReader(filename))) {
    while (s.hasNext()) {
        result.add(s.nextInt());
    }
    return result;
}

5. Utilisation deFiles.readAllLines

Le moyen le plus simple de lire un fichier et d'analyser toutes ses lignes en unArrayList est probablement d'utiliser lereadAllLines() method available in Files class: 

List result = Files.readAllLines(Paths.get(filename));

Cette méthode peut également prendre un paramètre charset, à lire selon un codage de caractères spécifique: 

Charset charset = Charset.forName("ISO-8859-1");
List result = Files.readAllLines(Paths.get(filename), charset);

6. Conclusion

Pour résumer, nous avons discuté de quelques façons courantes de lire le contenu d'unFile dans unArrayList. Nous avons également présenté certains avantages et inconvénients des différentes méthodes.

Par exemple, nous pouvons utiliserBufferedReader pour tamponner les caractères pour plus d'efficacité. Alternativement, nous pourrions utiliserScanner pour lire la primitive en utilisant des délimiteurs. Ou peut-être pourrions-nous simplement utiliserFiles.readAllLines(), sans nous soucier de l'implémentation sous-jacente.

Comme d'habitude, le code est disponible dans nosGitHub repository.

Related