Classe Java BufferedOutputStream

Dans ce didacticiel, nous allons découvrir Java BufferedOutputStream et ses méthodes à l'aide d'exemples.

Le BufferedOutputStream classe du java.io package est utilisé avec d'autres flux de sortie pour écrire les données (en octets) plus efficacement.

Il étend le OutputStream classe abstraite.

Fonctionnement de BufferedOutputStream

Le BufferedOutputStream maintient un tampon interne de 8192 octets .

Pendant l'opération d'écriture, les octets sont écrits dans la mémoire tampon interne au lieu du disque. Une fois le tampon rempli ou le flux fermé, tout le tampon est écrit sur le disque.

Par conséquent, le nombre de communications vers le disque est réduit. C'est pourquoi l'écriture d'octets est plus rapide avec BufferedOutputStream .

Créer un BufferedOutputStream

Pour créer un BufferedOutputStream , il faut importer le java.io.BufferedOutputStream paquet d'abord. Une fois que nous avons importé le package, voici comment nous pouvons créer le flux de sortie.

// Creates a FileOutputStream
FileOutputStream file = new FileOutputStream(String path);

// Creates a BufferedOutputStream
BufferedOutputStream buffer = new BufferOutputStream(file);

Dans l'exemple ci-dessus, nous avons créé un BufferdOutputStream nommé tampon avec le FileOutputStream nommé fichier .

Ici, le tampon interne a la taille par défaut de 8192 octets. Cependant, nous pouvons également spécifier la taille du tampon interne.

// Creates a BufferedOutputStream with specified size internal buffer
BufferedOutputStream buffer = new BufferOutputStream(file, int size);

Le tampon aidera à écrire des octets dans les fichiers plus rapidement.

Méthodes de BufferedOutputStream

Le BufferedOutputStream la classe fournit des implémentations pour différentes méthodes dans le OutputStream classe.

méthode write()

write() - écrit un seul octet dans le tampon interne du flux de sortie
write(byte[] array) - écrit les octets du tableau spécifié dans le flux de sortie
write(byte[] arr, int start, int length) - écrit le nombre d'octets égal à longueur au flux de sortie d'un tableau à partir de la position début

Exemple :BufferedOutputStream pour écrire des données dans un fichier

import java.io.FileOutputStream;
import java.io.BufferedOutputStream;

public class Main {
    public static void main(String[] args) {

        String data = "This is a line of text inside the file";

        try {
            // Creates a FileOutputStream
            FileOutputStream file = new FileOutputStream("output.txt");

            // Creates a BufferedOutputStream
            BufferedOutputStream output = new BufferedOutputStream(file);

            byte[] array = data.getBytes();

            // Writes data to the output stream
            output.write(array);
            output.close();
        }

        catch (Exception e) {
            e.getStackTrace();
        }
    }
}

Dans l'exemple ci-dessus, nous avons créé un flux de sortie tamponné nommé output avec FileOutputStream . Le flux de sortie est lié au fichier output.txt .

FileOutputStream file = new FileOutputStream("output.txt");
BufferedOutputStream output = new BufferedOutputStream(file);

Pour écrire des données dans le fichier, nous avons utilisé le write() méthode.

Ici, lorsque nous exécutons le programme, le output.txt le fichier est rempli avec le contenu suivant.

This is a line of text inside the file.

Remarque :Le getBytes() méthode utilisée dans le programme convertit une chaîne en un tableau d'octets.

Méthode flush()

Pour vider le tampon interne, nous pouvons utiliser le flush() méthode. Cette méthode force le flux de sortie à écrire toutes les données présentes dans le tampon dans le fichier de destination. Par exemple,

import java.io.FileOutputStream;
import java.io.BufferedOutputStream;

public class Main {
    public static void main(String[] args) {

        String data = "This is a demo of the flush method";

        try {
            // Creates a FileOutputStream
            FileOutputStream file = new FileOutputStream(" flush.txt");

            // Creates a BufferedOutputStream
            BufferedOutputStream buffer = new BufferedOutputStream(file);

            // Writes data to the output stream
            buffer.write(data.getBytes());

            // Flushes data to the destination
            buffer.flush();
            System.out.println("Data is flushed to the file.");
            buffer.close();
        }

        catch(Exception e) {
            e.getStackTrace();
        }
    }
}

Sortie

Data is flushed to the file.

Lorsque nous exécutons le programme, le fichier flush.txt est rempli avec le texte représenté par la chaîne data .

Méthode close()

Pour fermer le flux de sortie tamponné, nous pouvons utiliser le close() méthode. Une fois la méthode appelée, nous ne pouvons pas utiliser le flux de sortie pour écrire les données.

Pour en savoir plus, visitez Java BufferedOutputStream (documentation officielle de Java).

Classe Java BufferedInputStream Classe Java PrintStream

Java