La classe BufferedReader de Java lit le texte d'un flux de symboles et les met en tampon pour lire efficacement les caractères, tableaux et chaînes. Tu peux transmettre la taille de la mémoire tampon au constructeur en tant que deuxième argument.
Constructeurs :
![Les classes BufferedReader et BufferedWriter - 3]()

BufferedReader(Reader in) // Crée un flux mis en tampon pour la lecture de symboles. Il utilise la taille de la mémoire tampon par défaut.
BufferedReader(Reader in, int sz) // Crée un flux mis en tampon pour la lecture de symboles. Il utilise la taille de mémoire tampon spécifiée.
Méthodes :
close() // Ferme le flux
mark(int readAheadLimit) // Marque la position dans le flux
markSupported() // Indique si le marquage du flux est pris en charge
int read() // Lit le tampon
int read(char[] cbuf, int off, int len) // Lit le tampon
String readLine() // Ligne suivante
boolean ready() // Le flux est-il prêt à lire ?
reset() // Réinitialise le flux
skip(long n) // Ignore n caractères
Voici un exemple d'utilisation des classes BufferedReader et BufferedWriter :
Lecture d'un fichier :
import java.io.*;
public class ReadFile {
public static void main(String[] args) {
try {
File file = new File("file.txt");
FileReader fileReader = new FileReader(file); // Un flux qui se connecte au fichier texte
BufferedReader bufferedReader = new BufferedReader(fileReader); // Connecte le FileReader au BufferedReader
String line;
while((line = bufferedReader.readLine()) != null) {
System.out.println(line); // Affiche le contenu du fichier à l'écran, une ligne à la fois
}
bufferedReader.close(); // Ferme le flux
} catch (Exception e) {
e.printStackTrace();
}
}
}
La classe BufferedWriter de Java écrit du texte dans un flux de caractères de sortie, en mettant en tampon les caractères afin d'écrire efficacement des caractères, des tableaux et des chaînes. Tu peux transmettre la taille de la mémoire tampon au constructeur en tant que deuxième argument.
Constructeurs :
BufferedWriter(Writer out) // Crée un flux de sortie de caractères mis en tampon qui utilise la taille de mémoire tampon par défaut.
BufferedWriter(Writer out, int sz) // Crée un flux de sortie de caractères mis en tampon qui utilise une mémoire tampon avec la taille spécifiée.
Méthodes :
close() // Ferme le flux
flush() // Envoie les données de la mémoire tampon au Writer
newLine() // Passe à une nouvelle ligne
write(char[] cbuf, int off, int len) // Écrit dans le tampon
write(int c) // Écrit dans le tampon
write(String s, int off, int len) // Écrit dans le tampon
Voici un exemple d'utilisation des classes BufferedReader et BufferedWriter de Java :
Écriture dans un fichier :
import java.io.*;
public class WriteFile {
public static void main(String[] args) {
String[] list = {"un", "deux", "trois", "qu"};
try {
File file = new File("file.txt");
FileWriter fileReader = new FileWriter(file); // Un flux qui se connecte au fichier texte
BufferedWriter bufferedWriter = new BufferedWriter(fileReader); // Connecte le FileWriter au BufferedWriter
for (String s : list) {
bufferedWriter.write(s + "\n");
}
bufferedWriter.close (); // Ferme le flux
} catch (Exception e) {
e.printStackTrace();
}
}
}
FileWriter écrit immédiatement les données sur le disque. Chaque fois que nous y accédons, la mémoire tampon qui l'entoure accélère notre application. La mémoire tampon écrit des données en interne, puis écrit plus tard de gros blocs de fichier sur le disque.
Nous lisons les données de la console et les écrivons dans un fichier :
import java.io.*;
class ConsoleRead {
public static void main(String[] args) {
try {
File file = new File("file.txt");
InputStreamReader inputStreamReader = new InputStreamReader(System.in); // Un flux pour lire depuis la console
BufferedReader bufferedReader = new BufferedReader(inputStreamReader); // Connecte l'InputStreamReader à un BufferedReader
FileWriter fileReader = new FileWriter(file); // Un flux qui se connecte au fichier texte
BufferedWriter bufferedWriter = new BufferedWriter(fileReader); // Connecte le FileWriter au BufferedWriter
String line;
while(!(line = bufferedReader.readLine()).equals("quitter")) {
bufferedWriter.write(line);
}
bufferedReader.close(); // Ferme le flux
bufferedWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Cet article est également disponible en anglais: |
---|
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