CodeGym /Kursy /JAVA 25 SELF /BufferedReader, BufferedWriter: buforowanie, zalety

BufferedReader, BufferedWriter: buforowanie, zalety

JAVA 25 SELF
Poziom 36, Lekcja 0
Dostępny

1. Wprowadzenie

Przypomnijmy, jak działają FileReader i FileWriter. Za każdym razem, gdy wywołujesz u nich metodę read() lub write(), następuje dostęp do systemu plików — to znaczy komputer naprawdę sięga do dysku, aby odczytać lub zapisać jeden znak. Jeśli plik jest duży, a Ty czytasz lub zapisujesz po jednym znaku naraz, zmienia się to w maraton tysięcy, a nawet milionów odwołań do dysku. A dysk — jak wiadomo — nie jest najszybszym przyjacielem programisty.

Można sobie to wyobrazić tak: musisz przelać wodę z wiadra do butelki i robisz to łyżeczką do herbaty. Formalnie — działa, ale trwa strasznie długo. Dużo rozsądniej wziąć czerpak albo kubek. Z plikami jest podobnie: czytać lub pisać po jednym znaku to jak nosić wodę łyżeczką.

Tak to wygląda:

// Odczyt pliku znak po znaku (po "łyżeczce"!)
try (FileReader reader = new FileReader("big.txt")) {
    int c;
    while ((c = reader.read()) != -1) {
        // przetwarzamy znak (np. tylko zliczamy)
    }
}

Jeśli plik jest duży, zauważysz, że program działa bardzo powoli.

Buforowanie: co to jest i po co

Bufor to specjalny obszar pamięci (zwykle tablica), do którego dane są wczytywane lub zapisywane nie pojedynczymi znakami, lecz dużymi porcjami (np. po 8 KB lub więcej). Mówiąc prościej, bufor to kawałek pamięci, coś w rodzaju pośredniego „wiadra”, do którego dane są odczytywane lub zapisywane nie po jednym znaku, lecz większymi partiami.

Działa to tak: przy odczycie program raz sięga do dysku, ładuje do bufora cały blok danych, a potem spokojnie podaje je Tobie po jednym znaku z pamięci. Gdy blok się kończy, dociągany jest następny. Przy zapisie — ta sama logika: dane najpierw trafiają do bufora, a dopiero potem jednym dużym kawałkiem lądują na dysku (albo od razu, jeśli wywołasz flush()).

Dlaczego to szybsze? Bo dysk sam w sobie jest wolny, zwłaszcza gdy „szarpać” go drobnicą. Jeśli jednak zaglądać do niego rzadziej, ale brać więcej naraz, wszystko działa zauważalnie szybciej. Innymi słowy: buforowanie zmniejsza liczbę odwołań do dysku i przyspiesza program.

2. BufferedReader i BufferedWriter: składnia i przykłady

W Javie do buforowanego odczytu i zapisu plików tekstowych używa się dwóch klas:

  • BufferedReader — do odczytu plików tekstowych.
  • BufferedWriter — do zapisu plików tekstowych.

Działają one na wierzchu zwykłych Reader/Writer (np. FileReader/FileWriter), dodając buforowanie.

Odczyt pliku wiersz po wierszu za pomocą BufferedReader

Najczęstszy scenariusz — czytać plik wierszami. Metoda readLine() zwraca wiersz do znaku nowej linii ("\n" lub "\r\n").

import java.io.*;

public class BufferedReaderExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line); // Wypisujemy wiersz na ekran
            }
        } catch (IOException e) {
            System.out.println("Błąd podczas odczytu pliku: " + e.getMessage());
        }
    }
}

Co się tutaj dzieje?

Tworzymy FileReader, który potrafi czytać plik znak po znaku, i owijamy go w BufferedReader. Buforowany czytnik pobiera dane nie po jednym znaku, lecz dużymi porcjami, odkłada je w pamięci i podaje nam wierszami metodą readLine(). W efekcie piszesz po prostu pętlę while, dostajesz kolejne wiersze i nie zastanawiasz się nad rozmiarem pliku: odczyt i tak będzie szybki i oszczędny.

Zapis pliku za pomocą BufferedWriter

Wiersze do pliku można również zapisywać efektywnie:

import java.io.*;

public class BufferedWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            writer.write("Hello, world!");
            writer.newLine(); // Nowa linia (zależnie od systemu operacyjnego)
            writer.write("To jest drugi wiersz.");
        } catch (IOException e) {
            System.out.println("Błąd podczas zapisu pliku: " + e.getMessage());
        }
    }
}

Co się tutaj dzieje?

Najpierw tworzymy FileWriter, a następnie owijamy go w BufferedWriter. Gdy wywołujesz write() lub newLine(), dane nie trafiają od razu na dysk. Najpierw lądują w buforze — specjalnej warstwie pamięci. Dopiero gdy bufor się zapełni, albo gdy zamkniesz strumień (lub jawnie wywołasz flush()), cały zebrany tekst jest jednorazowo zapisywany do pliku. Takie podejście znacząco przyspiesza zapis i ogranicza liczbę odwołań do dysku.

Jak to wygląda w jednej aplikacji?

Załóżmy, że piszemy prostą aplikację‑„dziennik”, która zapisuje wpisy do pliku i wyświetla je na ekranie.

import java.io.*;
import java.util.Scanner;

public class DiaryApp {
    public static void main(String[] args) {
        String fileName = "diary.txt";
        Scanner scanner = new Scanner(System.in);

        // Zapis nowego wpisu
        System.out.print("Wprowadź nowy wpis do dziennika: ");
        String entry = scanner.nextLine();

        try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true))) {
            writer.write(entry);
            writer.newLine();
            System.out.println("Wpis zapisany!");
        } catch (IOException e) {
            System.out.println("Błąd podczas zapisu: " + e.getMessage());
        }

        // Odczyt wszystkich wpisów
        System.out.println("\nTwój dziennik:");
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("Błąd podczas odczytu: " + e.getMessage());
        }
    }
}

Bierzemy nazwę pliku "diary.txt" i prosimy użytkownika o wprowadzenie nowego wpisu. Do zapisu używamy FileWriter w trybie append (przekazujemy true), więc stare notatki nie są nadpisywane — każda nowa linia jest grzecznie dopisywana na końcu pliku. „Owinięcie” w BufferedWriter sprawia, że zapis jest szybki i oszczędny: dane najpierw kumulują się w pamięci, a potem jednym rzutem trafiają na dysk.

Następnie otwieramy ten sam plik do odczytu przez BufferedReader. On pobiera zawartość dużymi blokami, a Tobie oddaje wiersze po jednym. W pętli program po prostu wypisuje je na ekran, i w rezultacie widzisz cały swój „dziennik” od początku do końca.

3. Zalety BufferedReader i BufferedWriter

Znaczne przyspieszenie działania

Gdy czytasz lub zapisujesz plik za pomocą buforowanych strumieni, program wykonuje wielokrotnie mniej odwołań do dysku — czasem dziesiątki, a nawet setki razy mniej. Jest to szczególnie widoczne przy dużych plikach.

Wygodne metody

  • BufferedReader.readLine() — pozwala czytać plik wierszami, co jest bardzo wygodne przy obróbce plików tekstowych (np. logów, CSV, plików konfiguracyjnych).
  • BufferedWriter.newLine() — dodaje znak nowej linii, poprawny w zależności od systemu operacyjnego.

Prostota użycia

  • Klasy łatwo łączyć z innymi strumieniami (np. można owinąć InputStreamReader w BufferedReader, aby czytać pliki w różnych kodowaniach).
  • Automatyczne zamykanie wszystkich zasobów przy użyciu try-with-resources.

Elastyczność

  • Można jawnie ustawić rozmiar bufora, jeśli domyślny (zwykle 8 KB) jest dla Ciebie za mały lub za duży:
BufferedReader reader = new BufferedReader(new FileReader("big.txt"), 16384); // bufor o rozmiarze 16 KB

4. Kiedy używać BufferedReader i BufferedWriter

Używaj ich, gdy:

  • Pracujesz z plikami tekstowymi (logi, CSV, duże dane tekstowe).
  • Musisz czytać lub zapisywać plik wierszami.
  • Potrzebujesz przyspieszyć pracę z dużymi plikami, gdy wydajność ma znaczenie.
  • Musisz przetwarzać strumień danych z sieci lub innego źródła, które obsługuje Reader/Writer.

Nie używaj ich, gdy:

  • Pracujesz z plikami binarnymi (np. obrazami, archiwami, wideo) — do tego służą InputStream/OutputStream.
  • Plik jest bardzo mały i odczytywany/zapisywany jednorazowo w całości — zysk z buforowania będzie minimalny (choć i szkody nie będzie).

5. Przydatne niuanse

Łączenie z różnymi kodowaniami

Jeśli chcesz czytać/pisać pliki w określonym kodowaniu (np. "UTF-8", "Windows-1251"), użyj InputStreamReader/OutputStreamWriter w połączeniu z buforowanymi strumieniami:

BufferedReader reader = new BufferedReader(
    new InputStreamReader(new FileInputStream("input.txt"), "UTF-8")
);

BufferedWriter writer = new BufferedWriter(
    new OutputStreamWriter(new FileOutputStream("output.txt"), "UTF-8")
);

Jawne opróżnianie bufora

Czasem ważne jest, aby dane na pewno trafiły na dysk (np. gdy zapisujesz log lub paragon). W takim przypadku wywołaj writer.flush(). Zwykle nie jest to potrzebne, ponieważ zamknięcie strumienia automatycznie opróżnia bufor.

Rozmiar bufora

Domyślnie bufor ma około 8 KB. Można ustawić inny rozmiar, jeśli wiesz, że przyniesie to wzrost wydajności (np. przy przetwarzaniu ogromnych plików).

Porównanie: FileReader/FileWriter vs BufferedReader/BufferedWriter

Klasa Szybkość na dużych plikach Wygoda odczytu wierszami Wygoda zapisu wierszami Elastyczność w kwestii kodowań
FileReader/FileWriter Wolno Nie (tylko znak po znaku) Nie (tylko znak po znaku) Tylko domyślne
BufferedReader/Writer Szybko Tak (readLine()) Tak (newLine()) Tak (przez InputStreamReader/OutputStreamWriter)

6. Typowe błędy przy pracy z BufferedReader i BufferedWriter

Błąd nr 1: Zapomniano zamknąć strumień. Jeśli nie używasz try-with-resources lub nie wywołasz close(), plik może pozostać zablokowany, a dane — niezapisane na dysk. Zawsze używaj try-with-resources!

Błąd nr 2: Mylenie pracy z plikami tekstowymi i binarnymi. Próba otwarcia pliku binarnego (".jpg", ".zip") przez BufferedReader skończy się „krzaczkami” i najpewniej błędami. Do plików binarnych używaj InputStream/OutputStream.

Błąd nr 3: Brak buforowania przy dużych ilościach danych. Jeśli czytasz lub piszesz znak po znaku, program będzie działał wolno. Zawsze używaj buforowania dla dużych plików.

Błąd nr 4: Brak wywołania flush(), gdy to potrzebne. Jeśli chcesz, by dane natychmiast pojawiły się na dysku (np. do logowania), wywołaj writer.flush(). Zwykle jednak zamknięcie strumienia załatwia sprawę.

Błąd nr 5: Nieprawidłowe kodowanie. Jeśli otworzysz plik w niewłaściwym kodowaniu, tekst może wyświetlać się niepoprawnie (znaki zamienią się w „?”, krzaczki itd.). Zawsze jawnie podawaj właściwe kodowanie, jeśli różni się od systemowego (np. "UTF-8").

1
Zadanie
JAVA 25 SELF, poziom 36, lekcja 0
Niedostępne
Wydobycie pierwszej myśli ze starożytnego zwoju 📜
Wydobycie pierwszej myśli ze starożytnego zwoju 📜
1
Zadanie
JAVA 25 SELF, poziom 36, lekcja 0
Niedostępne
Zapis wielkiej prawdy w annały historii ✍️
Zapis wielkiej prawdy w annały historii ✍️
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION