Classe Java BufferedOutputStream

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

La classe BufferedOutputStream du paquet java.io est utilisée avec d'autres flux de sortie pour écrire des données de manière plus efficace (en octets).

Il hérite de la classe abstraite OutputStream.

fonctionnement de BufferedOutputStream

BufferedOutputStream maintient un8192octetstampon interne.

Durant l'opération d'écriture, les octets sont écrits dans le tampon interne plutôt que sur le disque. Une fois que le tampon est rempli ou que le flux est fermé, tout le tampon est écrit sur le disque.

Cela réduit le nombre de communications avec le disque. C'est pourquoi l'écriture d'octets avec BufferedOutputStream est plus rapide.

Create a BufferedOutputStream

Pour créer un BufferedOutputStream, nous devons d'abord importer le paquet java.io.BufferedOutputStream. Après avoir importé le paquet, nous pouvons créer un flux de sortie.

//Créer un FileOutputStream
FileOutputStream file = new FileOutputStream(String path);
//Create a BufferedOutputStream
BufferedOutputStream buffer = new BufferedOutputStream(file);

Dans l'exemple ci-dessus, nous avons créé un BufferedOutputStream nommé buffer, en utilisant un FileOutputStream nommé file.

Ici, la taille par défaut du tampon interne est8192octets. Mais, nous pouvons également spécifier la taille du tampon interne.

//Créer un BufferedOutputStream avec un tampon interne de taille spécifiée
BufferedOutputStream buffer = new BufferedOutputStream(file, int size);

Ce buffer aidera à écrire les octets dans le fichier plus rapidement.

méthodes de BufferedOutputStream

La classe BufferedOutputStream fournit des implémentations pour différentes méthodes de la classe OutputStream.

méthode write()

• write() - Écrire un byte unique dans le tampon interne du flux de sortie

• write(byte[] array) - Écrire les bytes du tableau spécifié dans le flux de sortie

• write(byte[] arr, int start, int length)- Écrire un nombre égal à length de bytes à partir de la position start dans le flux de sortie du tableau

Exemple : BufferedOutputStream écrit des données dans le 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 {
　　　　　　　　　　　　//Créer un FileOutputStream
　　　　　　　　　　　　FileOutputStream file = new FileOutputStream("output.txt");
　　　　　　　　　　　　//Create a BufferedOutputStream
　　　　　　　　　　　　BufferedOutputStream output = new BufferedOutputStream(file);
　　　　　　　　　　　　byte[] array = data.getBytes();
　　　　　　　　　　　　//Write data to the output stream
　　　　　　　　　　　　output.write(array);
　　　　　　　　　　　　output.close();
　　　　　　　　}
　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

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

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

Lorsque nous exécutons le programme,output.txtLe fichier contiendra le contenu suivant.

This is a line of text inside the file.

Remarque：Dans le programme, la méthode getBytes() est utilisée pour convertir une chaîne en tableau de bytes.

Méthode flush()

Pour vider le tampon interne, nous pouvons utiliser la méthode flush(). Cette méthode force le flux de sortie à écrire tous les données existantes dans le tampon vers le fichier cible. 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 {
　　　　　　　　　　　　//Créer un FileOutputStream
　　　　　　　　　　　　FileOutputStream file = new FileOutputStream("flush.txt");
　　　　　　　　　　　　//Create a BufferedOutputStream
　　　　　　　　　　　　BufferedOutputStream buffer = new BufferedOutputStream(file);
　　　　　　　　　　　　//Write data to the output stream
　　　　　　　　　　　　buffer.write(data.getBytes());
　　　　　　　　　　　　//Push data into the target
　　　　　　　　　　　　buffer.flush();
　　　　　　　　　　　　System.out.println("Data is pushed into the file.");
　　　　　　　　　　　　buffer.close();
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

Output result

Data is pushed into the file.

When we run the program, the file flush.txt is filled with text represented by string data.

close() method

To close the buffered output stream, we can use the close() method. After calling this method, we will not be able to use the output stream to write data.