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").
GO TO FULL VERSION