Die Java-Klasse BufferedReader liest Text aus einem Strom von Symbolen und puffert die Symbole, um Zeichen, Arrays und Strings effizient einzulesen. Du kannst die Puffergröße als zweites Argument an den Konstruktor übergeben.
Konstruktoren:
![Die Klassen BufferedReader und BufferedWriter - 3]()

BufferedReader(Reader in) // Erstellt einen gepufferten Stream zum Lesen von Symbolen. Er nutzt die Standardpuffergröße.
BufferedReader(Reader in, int sz) // Erstellt einen gepufferten Stream zum Lesen von Symbolen. Er nutzt die angegebene Puffergröße.
Methoden:
close() // Stream schließen
mark(int readAheadLimit) // Position im Stream markieren
markSupported() // Gibt an, ob die Stream-Markierung unterstützt wird
int read() // Puffer lesen
int read(char[] cbuf, int off, int len) // Puffer lesen
String readLine() // Nächste Zeile
boolean ready() // Ist der Stream bereit zum Lesen?
reset() // Stream zurücksetzen
skip(long n) // Zeichen überspringen
Hier ist ein Beispiel für die Verwendung die Java-Klasse BufferedReader und die Java-Klasse BufferedWriter in Java:
Eine Datei einlesen:
import java.io.*;
public class ReadFile {
public static void main(String[] args) {
try {
File file = new File("file.txt");
FileReader fileReader = new FileReader(file); // Ein Stream, der eine Verbindung zur Textdatei herstellt
BufferedReader bufferedReader = new BufferedReader(fileReader); // FileReader mit BufferedReader verbinden
String line;
while((line = bufferedReader.readLine()) != null) {
System.out.println(line); // Dateiinhalt Zeile für Zeile auf dem Bildschirm anzeigen
}
bufferedReader.close(); // Stream schließen
} catch (Exception e) {
e.printStackTrace();
}
}
}
Javas BufferedWriter-Klasse schreibt Text in einen Ausgabezeichenstrom und puffert die Zeichen, um Zeichen, Arrays und Zeichenketten effizient auszugeben. Du kannst die Puffergröße als zweites Argument an den Konstruktor übergeben.
Konstruktoren:
BufferedWriter(Writer out) // Gepufferten Ausgabezeichenstrom erstellen, der die Standardpuffergröße verwendet.
BufferedWriter(Writer out, int sz) // Erstellt einen gepufferten Zeichenausgabestrom, der einen Puffer mit der angegebenen Größe verwendet.
Methoden:
close() // Stream schließen
flush() // Daten aus dem Puffer an den Writer senden
newLine() // In eine neue Zeile springen
write(char[] cbuf, int off, int len) // In den Puffer schreiben
write(int c) // In den Puffer schreiben
write(String s, int off, int len) // In den Puffer schreiben
Hier ist ein Beispiel für die Verwendung der Java-Klassen BufferedReader und BufferedWriter:
Eine Datei mit Java schreiben:
import java.io.*;
public class WriteFile {
public static void main(String[] args) {
String[] list = {"eines", "zwei", "drei", "vi"};
try {
File file = new File("file.txt");
FileWriter fileReader = new FileWriter(file); // Ein Stream, der eine Verbindung zur Textdatei herstellt
BufferedWriter bufferedWriter = new BufferedWriter(fileReader); // FileWriter mit dem BufferedWriter verbinden
for (String s : list) {
bufferedWriter.write(s + "\n");
}
bufferedWriter.close (); // Stream schließen
} catch (Exception e) {
e.printStackTrace();
}
}
}
Die Java-Klasse FileWriter schreibt Daten direkt auf die Festplatte. Jedes Mal, wenn wir auf sie zugreifen, beschleunigt der sie umgebende Puffer unsere Anwendung. Der Puffer schreibt die Daten intern und schreibt dann später große Dateiblöcke auf die Festplatte.
Wir lesen Daten von der Konsole und schreiben sie in eine Datei:
import java.io.*;
class ConsoleRead {
public static void main(String[] args) {
try {
File file = new File("file.txt");
InputStreamReader inputStreamReader = new InputStreamReader(System.in); // Ein Stream zum Lesen von der Konsole
BufferedReader bufferedReader = new BufferedReader(inputStreamReader); // InputStreamReader mit einem BufferedReader verbinden
FileWriter fileReader = new FileWriter(file); // Ein Stream, der eine Verbindung zur Textdatei herstellt
BufferedWriter bufferedWriter = new BufferedWriter(fileReader); // FileWriter mit dem BufferedWriter verbinden
String line;
while(!(line = bufferedReader.readLine()).equals("exit")) {
bufferedWriter.write(line);
}
bufferedReader.close(); // Stream schließen
bufferedWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Dieser Beitrag ist auf Englisch verfügbar. |
---|
Read the English version of this article to better understand Java’s BufferedReader and BufferedWriter classes. Find out why and how they use buffering to your advantage. |

GO TO FULL VERSION