Maîtriser Java BufferedInputStream : Lecture d'octets efficace et méthodes avancées

Maîtriser Java BufferedInputStream : Lecture d'octets efficace et méthodes avancées

La classe BufferedInputStream du package java.io améliore les flux d'entrée d'octets en ajoutant un tampon interne, permettant une lecture de données plus rapide et plus efficace.

Elle étend la classe abstraite InputStream.

---

Comment fonctionne BufferedInputStream

BufferedInputStream maintient un tampon interne de 8 192 octets par défaut. Lors d'une opération de lecture, un bloc d'octets est récupéré depuis le flux sous-jacent (généralement un fichier) et stocké dans ce tampon. Les appels de lecture suivants consomment les octets du tampon jusqu'à son épuisement, moment où un autre bloc est chargé. Cela réduit les coûteuses E/S disque et accélère la consommation de données.

---

Création d'un BufferedInputStream

Importez la classe :

import java.io.BufferedInputStream;
import java.io.FileInputStream;

Puis instanciez-la en encapsulant un flux de niveau inférieur comme FileInputStream :

FileInputStream fichier = new FileInputStream("exemple.txt");
BufferedInputStream tampon = new BufferedInputStream(fichier);

Optionnellement, spécifiez une taille de tampon personnalisée :

int tailleTampon = 16_384; // 16 Ko
BufferedInputStream tampon = new BufferedInputStream(fichier, tailleTampon);

Plus le tampon est grand, moins d'accès disque sont nécessaires — utile pour les gros fichiers ou flux réseau.

---

Méthodes principales de BufferedInputStream

read()

• int read() – lit un octet unique, le renvoie comme entier (0–255) ou -1 si fin de flux
• int read(byte[] b) – lit jusqu'à b.length octets dans le tableau
• int read(byte[] b, int off, int len) – lit jusqu'à len octets dans b à partir de l'offset off

Exemple : Lecture d'un fichier texte octet par octet et affichage console.

import java.io.BufferedInputStream;
import java.io.FileInputStream;

public class Main {
    public static void main(String[] args) {
        try (BufferedInputStream in = new BufferedInputStream(new FileInputStream("input.txt"))) {
            int octetLu;
            while ((octetLu = in.read()) != -1) {
                System.out.print((char) octetLu);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Sortie :

Ceci est une ligne de texte dans le fichier.

available()

available() indique le nombre d'octets lisibles sans blocage. Utile pour suivre la progression sur de gros flux.

FileInputStream fichier = new FileInputStream("input.txt");
BufferedInputStream tampon = new BufferedInputStream(fichier);
System.out.println("Octets disponibles : " + tampon.available());
// ... lecture de données
System.out.println("Octets restants : " + tampon.available());
tampon.close();

skip(long n)

Utilisez skip() pour contourner un nombre spécifié d'octets. Renvoie le nombre réel d'octets ignorés, qui peut être inférieur si la fin du flux est atteinte.

tampon.skip(5); // ignore les 5 premiers octets

close()

Fermez toujours le flux (de préférence avec try-with-resources) pour libérer les ressources. Après fermeture, le flux ne peut plus être réutilisé.

---

Autres méthodes notables

Méthode	Description
mark(int readLimit)	Marque la position courante. reset() y reviendra, si moins de readLimit octets ont été lus.
reset()	Repositionne le flux à la dernière position marquée.

Pour une référence complète, consultez la documentation officielle Java.