Java java.nio.file.Files.lines()Méthode

Java File Java java.nio.file.Files

Files.lines()La méthode est une méthode statique introduite dans Java 8, située dans lajava.nio.file.Filesclasse. Son objectif principal est de renvoyer le contenu d'un fichier sous forme de flux de chaînes (Stream<String>), où chaque chaîne représente une ligne du fichier.

Définition de méthode

public static Stream<String> lines(Path path) throws IOException
public static Stream<String> lines(Path path, Charset cs) throws IOException

La méthode possède deux versions surchargées :

  1. La première version lit les fichiers en utilisant le jeu de caractères par défaut (UTF-8)
  2. La seconde version permet de spécifier un jeu de caractères

Fonctionnalités principales

1. Évaluation paresseuse

lines()La méthode renvoie un Stream, ce qui signifie qu'elle est évaluée paresseusement. Le fichier n'est pas entièrement chargé en mémoire d'un coup, mais lu à la demande, ce qui est particulièrement bénéfique pour le traitement de gros fichiers.

2. Gestion automatique des ressources

Lorsque l'opération de flux se termine (qu'elle se termine normalement ou soit interrompue par une exception), le flux ferme automatiquement les ressources de fichier sous-jacentes. Cependant, la meilleure pratique reste d'utiliser l'instruction try-with-resources pour garantir que les ressources sont correctement libérées.

3. Gestion des terminateurs de ligne

La méthode reconnaît automatiquement différents terminateurs de ligne :

  • \n(Unix/Linux)
  • \r\n(Windows)
  • \r(ancien Mac)

Utilisation de base

Exemple 1 : Lecture simple de fichier

Exemple

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class FilesLinesExample {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
       
        try (Stream<String> lines = Files.lines(path)) {
            lines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Exemple 2 : Utilisation d'un jeu de caractères spécifié

Exemple

try (Stream<String> lines = Files.lines(path, StandardCharsets.ISO_8859_1)) {
    lines.filter(line -> !line.isEmpty())
         .forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

Utilisation avancée

1. Combinaison avec l'API Stream

Exemple

// Compter les lignes non vides
long count = Files.lines(path)
                 .filter(line -> !line.trim().isEmpty())
                 .count();

// Trouver les lignes contenant un mot spécifique
List<String> targetLines = Files.lines(path)
                               .filter(line -> line.contains("important"))
                               .collect(Collectors.toList());

2. Traitement parallèle

Exemple

// Traiter les lignes de fichier en parallèle
Files.lines(path)
     .parallel()
     .map(String::toUpperCase)
     .forEachOrdered(System.out::println);

Notes

  1. Gestion des ressources: Bien que le flux se ferme automatiquement, l'utilisation explicite de try-with-resources est toujours recommandée dans les opérations de flux complexes.

  2. Considérations de performance: Pour les petits fichiers,Files.readAllLines()peut être plus simple ; mais pour les fichiers volumineux,lines()est un meilleur choix.

  3. Problèmes de jeu de caractères: Si l'encodage du fichier diffère de l'encodage par défaut du système, veillez à spécifier le bon jeu de caractères ; sinon, du texte illisible peut être lu.

  4. Gestion des exceptions: Les opérations d'E/S peuvent lever des exceptions et doivent être correctement gérées.


Comparaison des performances

Méthode Fonctionnalités Scénarios applicables
Files.lines() Chargement paresseux, efficacité mémoire élevée Traitement de fichiers volumineux
Files.readAllLines() Charge toutes les lignes en mémoire en une seule fois Traitement de petits fichiers
BufferedReader.readLine() Approche traditionnelle, contrôle manuel Lorsqu'un contrôle précis est nécessaire

Résumé

Files.lines()La méthode combine l'API Stream de Java 8 avec les capacités efficaces de traitement de fichiers de NIO, offrant une solution moderne et concise pour la lecture de fichiers. Elle est particulièrement adaptée au traitement de fichiers volumineux et à l'exécution d'opérations complexes au niveau des lignes. Maîtriser cette méthode peut considérablement améliorer la lisibilité et l'efficacité du code de traitement de fichiers.

Dans le développement réel, en fonction de la taille du fichier, des exigences de traitement et des besoins de performance, choisissez raisonnablementlines()、readAllLines()ou les méthodes IO traditionnelles pour écrire un code de traitement de fichiers optimal.

Java File Java java.nio.file.Files

Autres extensions