Lire un fichier dans une ArrayList

1. Vue d'ensemble

Dans ce didacticiel, nous aborderons différentes manières de lire un fichier dans une ArrayList .

Il existe de nombreuses façons de lire un fichier en Java. Une fois que nous avons lu un fichier, nous pouvons effectuer de nombreuses opérations sur le contenu de ce fichier.

Certaines de ces opérations, comme le tri, peuvent nécessiter le traitement de l'intégralité du contenu du fichier en mémoire. Afin d'effectuer de telles opérations, nous pouvons avoir besoin de lire le fichier sous forme de tableau ou de liste de lignes ou de mots.

2. Utilisation de FileReader

Le moyen le plus simple de lire un fichier en Java consiste à utiliser FileReader . Par définition, FileReader est une classe pratique pour lire un flux de caractères à partir d'un fichier.

Il existe plusieurs constructeurs disponibles pour initialiser un FileReader:

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

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

Cependant, si nous voulons fournir un encodage de caractères personnalisé et une taille de tampon d'octets, nous pouvons utiliser InputStreamReader ou FileInputStream .

Dans le code suivant, nous allons montrer comment lire les lignes d'un fichier dans un ArrayList, à l' aide de FileReader:

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 de BufferedReader

Bien que FileReader soit assez facile à utiliser, il est conseillé de toujours l'envelopper avec BuffereReader , lors de la lecture d'un fichier.

Cela est dû au fait que BufferedReader utilise un tampon de caractères pour lire simultanément plusieurs valeurs à partir d'un flux d'entrée de caractères et réduit par conséquent le nombre d' appels read () effectués par le FileStream sous-jacent .

Les constructeurs de BufferedReader prennent Reader comme entrée. De plus, nous pouvons également fournir la taille du tampon dans les constructeurs, mais, pour 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 classe Reader , BufferedReader fournit également la méthode readLine () , pour lire une ligne entière sous forme de chaîne:

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

4. Utilisation du scanner

Un autre moyen courant de lire des fichiers est d' utiliser Scanner .

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, le scanner est initialisé à l'aide d' objets File ou FileReader :

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

Semblable à BufferedReader, Scanner fournit la méthode readLine () pour lire une ligne entière . De plus , il fournit également une méthode hasNext () pour indiquer si d'autres 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; }

Le 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éthodes next ( 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 de Files.readAllLines

Le moyen le plus simple de lire un fichier et d'analyser toutes ses lignes dans un ArrayList est d'utiliser la méthode readAllLines () disponible dans la classe Files :

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

Cette méthode peut également prendre un paramètre charset, à lire selon un encodage 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'un fichier dans une ArrayList . En outre, nous avons couvert certains avantages et inconvénients des différentes méthodes.

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

Comme d'habitude, le code est disponible dans notre référentiel GitHub.