Traitement de texte efficace avec Java BufferedReader

Introduction

Dans ce laboratoire, nous allons utiliser la classe Java BufferedReader, qui est partie du package java.io. BufferedReader est utilisé pour lire du texte à partir d'un flux d'entrée de caractères et bufferise les caractères pour une meilleure performance. La classe encapsule d'autres classes de lecteurs et flux d'entrée, permettant d'améliorer l'efficacité et la performance globale de nos programmes. Nous allons explorer les différents constructeurs, méthodes et cas d'utilisation de BufferedReader afin de comprendre sa fonctionnalité.

Skills Graph

Créer un BufferedReader avec un FileReader

Le constructeur de BufferedReader prend un objet Reader en tant que paramètre. Nous pouvons créer un lecteur en utilisant un FileReader, qui lit les fichiers texte dans l'encodage par défaut. Dans cette étape, nous allons lire un fichier avec la classe BufferedReader en enveloppant un FileReader.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        String path = "path/to/your/file.txt";
        try {
            FileReader fileReader = new FileReader(path);
            BufferedReader bufferedReader = new BufferedReader(fileReader); //Création d'un BufferedReader en enveloppant le FileReader
            // Ajoutez le code pour lire les données à partir du fichier ici

            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Pour exécuter le code, compilez le fichier avec javac BufferedReaderDemo.java, puis exécutez-le avec java BufferedReaderDemo.

Utiliser un BufferedReader avec un flux

Nous pouvons également créer un BufferedReader en utilisant un flux d'entrée comme source. Dans cette étape, nous allons envelopper un InputStreamReader avec BufferedReader et lire des données à partir de System.in. Cela lira les données que nous entrons au clavier.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader bufferedReader = new BufferedReader(isr); //Création d'un BufferedReader
            System.out.println("Entrez quelque chose :");
            String line = bufferedReader.readLine(); //Lire l'entrée à partir de la console
            System.out.println("Vous avez entré : " + line); //Afficher l'entrée

            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Fermeture du flux

Nous devrions toujours utiliser la méthode close() du BufferedReader pour libérer toutes les ressources système associées au lecteur. Pour simplifier le code, nous pouvons utiliser un bloc try-with-resources pour fermer automatiquement le flux.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        String path = "path/to/your/file.txt";
        try (FileReader fileReader = new FileReader(path);
             BufferedReader bufferedReader = new BufferedReader(fileReader)) {

            // Ajoutez le code pour lire les données à partir du fichier ici

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BufferedReader Vs. Scanner

Both Scanner and BufferedReader can be used to read data from external sources. However, there are some differences between these two classes. In this step, we will compare some key differences.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        String path = "path/to/your/file.txt";
        try (FileReader fileReader = new FileReader(path);
             BufferedReader bufferedReader = new BufferedReader(fileReader);
             Scanner scanner = new Scanner(fileReader)) {
            long startTime = System.nanoTime();
            // Reading file with BufferedReader
            bufferedReader.readLine();
            while (bufferedReader.readLine()!= null) ;
            long endTime = System.nanoTime();
            System.out.println("Time taken by BufferedReader : " + (endTime - startTime) + "ns");

            startTime = System.nanoTime();
            // Reading file with Scanner
            scanner.nextLine();
            while (scanner.hasNextLine()) scanner.nextLine();
            endTime = System.nanoTime();
            System.out.println("Time taken by Scanner : " + (endTime - startTime) + "ns");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This code compares the time taken by BufferedReader and Scanner to read data from the same file. The timings will vary, but the output will tell you which one took longer.

Lecture de fichiers ligne par ligne

La classe BufferedReader fournit plusieurs méthodes pour lire des données. La méthode readLine() lit une ligne à la fois. Cette méthode renvoie null si nous arrivons à la fin du flux. Dans cette étape, nous allons lire un fichier à l'aide de BufferedReader.readLine().

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        String path = "path/to/your/file.txt";
        try (FileReader fileReader = new FileReader(path);
             BufferedReader bufferedReader = new BufferedReader(fileReader)) {

            String line;
            while ((line = bufferedReader.readLine())!= null) {
                System.out.println(line);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Lecture de caractères individuels à partir d'un fichier

Nous pouvons également lire un seul caractère à la fois en utilisant la méthode read() de la classe BufferedReader. Cette méthode renvoie le caractère lu sous forme d'un entier. Si nous arrivons à la fin du flux, elle renvoie -1.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        String path = "path/to/your/file.txt";
        try (FileReader fileReader = new FileReader(path);
             BufferedReader bufferedReader = new BufferedReader(fileReader)) {

            int charRead;
            while ((charRead = bufferedReader.read())!= -1) {
                System.out.print((char) charRead);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Lecture de plusieurs caractères à partir d'un fichier

La méthode read() peut lire plusieurs caractères à la fois. Nous devons passer un tableau de caractères dans lequel elle stockera les données. Nous devons également utiliser un décalage qui indique l'index de départ du tableau de caractères. Les données stockées commencent à cet index. Nous devons également mentionner la longueur maximale de caractères à lire.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        String path = "path/to/your/file.txt";
        try (FileReader fileReader = new FileReader(path);
             BufferedReader bufferedReader = new BufferedReader(fileReader)) {

            char[] charArr = new char[5];
            bufferedReader.read(charArr, 0, 5);
            System.out.print(charArr);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Ignorer des caractères

La classe BufferedReader fournit une méthode skip(), que nous pouvons utiliser pour ignorer des caractères. Elle prend un paramètre de type long.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        String path = "path/to/your/file.txt";
        try (FileReader fileReader = new FileReader(path);
             BufferedReader bufferedReader = new BufferedReader(fileReader)) {

            int charRead;
            StringBuilder sb = new StringBuilder();
            while ((charRead = bufferedReader.read())!= -1) {
                if (charRead!= '*') {
                    sb.append((char) charRead);
                } else {
                    bufferedReader.skip(1);
                }
            }
            System.out.println(sb);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Marquer et réinitialiser

La classe BufferedReader nous fournit la méthode mark() pour marquer un caractère spécifique. Nous pouvons revenir à ce caractère marqué à tout moment dans le futur en utilisant la méthode reset(). La méthode mark() prend un entier en entrée qui indique le nombre maximum d'octets qui peuvent être lus avant que le marqueur ne devienne invalide.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        String path = "path/to/your/file.txt";
        try (FileReader fileReader = new FileReader(path);
             BufferedReader bufferedReader = new BufferedReader(fileReader)) {

            char[] charArr = new char[5];
            charArr[0] = (char) bufferedReader.read();
            charArr[1] = (char) bufferedReader.read();

            bufferedReader.mark(10);
            bufferedReader.skip(1);
            charArr[2] = (char) bufferedReader.read();
            charArr[3] = (char) bufferedReader.read();
            charArr[4] = (char) bufferedReader.read();
            System.out.println(charArr);

            bufferedReader.reset();
            char asterisk = (char) bufferedReader.read();
            System.out.print(asterisk);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Sommaire

Dans ce laboratoire, nous avons utilisé la classe Java BufferedReader pour lire du texte à partir d'un flux d'entrée de caractères. Nous avons appris à envelopper d'autres classes de lecteurs et de flux d'entrée avec BufferedReader pour améliorer les performances et l'efficacité. Nous avons abordé des sujets tels que la lecture de caractères individuels et multiples à partir d'un fichier, le saut de caractères, le marquage et le réinitialisation des positions dans un fichier, et la comparaison des classes BufferedReader et Scanner. Nous avons également utilisé des blocs try-with-resources pour fermer automatiquement le flux et éviter les fuites mémoire.