Effektive Textverarbeitung mit der Java BufferedReader

Einführung

In diesem Lab verwenden wir die Java-Klasse BufferedReader, die zum Paket java.io gehört. BufferedReader wird verwendet, um Text aus einem Zeicheneingabestream zu lesen und die Zeichen zu puffernd, um eine bessere Leistung zu erzielen. Die Klasse umschließt andere Reader-Klassen und Eingabestreams, was es uns ermöglicht, die Gesamtleistung und Effizienz unserer Programme zu verbessern. Wir werden die verschiedenen Konstruktoren, Methoden und Anwendungsfälle von BufferedReader untersuchen, um seine Funktionalität zu verstehen.

Erstellen Sie einen BufferedReader mit einem FileReader

Der BufferedReader-Konstruktor nimmt ein Reader-Objekt als Parameter. Wir können einen Reader mit einem FileReader erstellen, der Textdateien in der Standardcodierung liest. In diesem Schritt werden wir eine Datei mit der BufferedReader-Klasse lesen, indem wir einen FileReader umschließen.

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); // Erstellen eines BufferedReader, indem der FileReader umschlossen wird
            // Fügen Sie hier den Code hinzu, um Daten aus der Datei zu lesen

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

Um den Code auszuführen, kompilieren Sie die Datei mit javac BufferedReaderDemo.java, und führen Sie sie dann mit java BufferedReaderDemo aus.

Verwenden Sie einen BufferedReader mit einem Stream

Wir können auch einen BufferedReader mit einem Eingabestream als Quelle erstellen. In diesem Schritt werden wir einen InputStreamReader mit BufferedReader umschließen und Daten aus System.in lesen. Dies wird die Daten lesen, die wir über die Tastatur eingeben.

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); // Erstellen eines BufferedReader
            System.out.println("Enter Something:");
            String line = bufferedReader.readLine(); // Eingabe aus der Konsole lesen
            System.out.println("You Entered: " + line); // Die Eingabe ausgeben

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

Den Stream schließen

Wir sollten immer die close()-Methode des BufferedReader verwenden, um alle mit dem Reader assoziierten Systemressourcen freizugeben. Um den Code zu vereinfachen, können wir einen try-with-resources-Block verwenden, um den Stream automatisch zu schließen.

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)) {

            // Fügen Sie hier den Code hinzu, um Daten aus der Datei zu lesen

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

BufferedReader vs. Scanner

Beide Scanner und BufferedReader können verwendet werden, um Daten aus externen Quellen zu lesen. Es gibt jedoch einige Unterschiede zwischen diesen beiden Klassen. In diesem Schritt werden wir einige der wichtigsten Unterschiede vergleichen.

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();
            // Datei mit BufferedReader lesen
            bufferedReader.readLine();
            while (bufferedReader.readLine()!= null) ;
            long endTime = System.nanoTime();
            System.out.println("Zeit, die von BufferedReader benötigt wird: " + (endTime - startTime) + "ns");

            startTime = System.nanoTime();
            // Datei mit Scanner lesen
            scanner.nextLine();
            while (scanner.hasNextLine()) scanner.nextLine();
            endTime = System.nanoTime();
            System.out.println("Zeit, die von Scanner benötigt wird: " + (endTime - startTime) + "ns");

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

Dieser Code vergleicht die Zeit, die BufferedReader und Scanner benötigen, um Daten aus derselben Datei zu lesen. Die Messwerte werden variieren, aber die Ausgabe wird Ihnen sagen, welches von beiden länger dauerte.

Zeilenweise Dateien lesen

Die BufferedReader-Klasse bietet mehrere Methoden zum Lesen von Daten. Die readLine()-Methode liest eine Zeile nach der anderen. Diese Methode gibt null zurück, wenn wir am Ende des Streams angelangt sind. In diesem Schritt werden wir eine Datei mit BufferedReader.readLine() lesen.

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

Einzelne Zeichen aus einer Datei lesen

Wir können auch ein einzelnes Zeichen pro Mal lesen, indem wir die read()-Methode der BufferedReader-Klasse verwenden. Diese Methode gibt das gelesene Zeichen als Integer zurück. Wenn wir am Ende des Streams angelangt sind, gibt sie -1 zurück.

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

Mehrere Zeichen aus einer Datei lesen

Die read()-Methode kann mehrere Zeichen gleichzeitig lesen. Wir müssen ein Zeichenarray übergeben, in dem die Daten gespeichert werden. Wir müssen auch einen Offset verwenden, der den Startindex des Zeichenarrays angibt. Die gespeicherten Daten beginnen ab diesem Index. Wir müssen auch die maximale Anzahl von zu lesenden Zeichen angeben.

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

Zeichen überspringen

Die BufferedReader-Klasse bietet eine skip()-Methode, die wir verwenden können, um Zeichen zu überspringen. Sie nimmt einen Parameter vom Typ 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();
        }
    }
}

Markieren und Zurücksetzen

Die BufferedReader-Klasse bietet uns die mark()-Methode, um ein bestimmtes Zeichen zu markieren. Wir können zu diesem markierten Zeichen zu einem späteren Zeitpunkt zurückkehren, indem wir die reset()-Methode verwenden. Die mark()-Methode nimmt eine Ganzzahl als Eingabe entgegen, die die maximale Anzahl von Bytes angibt, die vor dem Ungültigwerden des Markers gelesen werden können.

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

Zusammenfassung

In diesem Lab haben wir die Java-BufferedReader-Klasse verwendet, um Text aus einem Zeicheneingabestream zu lesen. Wir haben gelernt, wie andere Reader-Klassen und Eingabestreams mit BufferedReader umwickelt werden können, um die Leistung und Effizienz zu verbessern. Wir haben Themen wie das Lesen einzelner und mehrerer Zeichen aus einer Datei, das Überspringen von Zeichen, das Markieren und Zurücksetzen von Positionen in einer Datei sowie das Vergleich der BufferedReader- und Scanner-Klassen behandelt. Wir haben auch try-with-resources-Blöcke verwendet, um den Stream automatisch zu schließen und Speicherlecks zu vermeiden.