Classe Java BufferedInputStream

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

Le BufferedInputStream classe du java.io package est utilisé avec d'autres flux d'entrée pour lire les données (en octets) plus efficacement.

Il étend le InputStream classe abstraite.

Fonctionnement de BufferedInputStream

Le BufferedInputStream maintient un tampon interne de 8192 octets .

Lors de l'opération de lecture en BufferedInputStream , un bloc d'octets est lu à partir du disque et stocké dans la mémoire tampon interne. Et à partir du tampon interne, les octets sont lus individuellement.

Par conséquent, le nombre de communications vers le disque est réduit. C'est pourquoi la lecture des octets est plus rapide en utilisant le BufferedInputStream .

Créer un BufferedInputStream

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

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

// Creates a BufferedInputStream
BufferedInputStream buffer = new BufferInputStream(file);

Dans l'exemple ci-dessus, nous avons créé un BufferdInputStream nommé tampon avec le FileInputStream 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 BufferedInputStream with specified size internal buffer
BufferedInputStream buffer = new BufferInputStream(file, int size);

Le tampon aidera à lire plus rapidement les octets des fichiers.

Méthodes de BufferedInputStream

Le BufferedInputStream la classe fournit des implémentations pour différentes méthodes présentes dans le InputStream classe.

méthode read()

read() - lit un seul octet du flux d'entrée
read(byte[] arr) - lit les octets du flux et les stocke dans le tableau spécifié
read(byte[] arr, int start, int length) - lit le nombre d'octets égal à la longueur à partir du flux et stocke dans le tableau spécifié à partir de la position début

Supposons que nous ayons un fichier nommé input.txt avec le contenu suivant.

This is a line of text inside the file.

Essayons de lire le fichier en utilisant BufferedInputStream .

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

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

            // Creates a FileInputStream
            FileInputStream file = new FileInputStream("input.txt");

            // Creates a BufferedInputStream
            BufferedInputStream input = new BufferedInputStream(file);

            // Reads first byte from file
            int i = input .read();

            while (i != -1) {
                System.out.print((char) i);

                // Reads next byte from the file
                i = input.read();
            }
            input.close();
        }

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

Sortie

This is a line of text inside the file.

Dans l'exemple ci-dessus, nous avons créé un flux d'entrée mis en mémoire tampon nommé buffer avec FileInputStream . Le flux d'entrée est lié au fichier input.txt .

FileInputStream file = new FileInputStream("input.txt");
BufferedInputStream buffer = new BufferedInputStream(file);

Ici, nous avons utilisé le read() méthode pour lire un tableau d'octets à partir du tampon interne du lecteur tamponné.

méthode available()

Pour obtenir le nombre d'octets disponibles dans le flux d'entrée, nous pouvons utiliser le available() méthode. Par exemple,

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

public class Main {

   public static void main(String args[]) {

      try {

         // Suppose, the input.txt file contains the following text
         // This is a line of text inside the file.
         FileInputStream file = new FileInputStream("input.txt");
         
         // Creates a BufferedInputStream
         BufferedInputStream buffer = new BufferedInputStream(file);

         // Returns the available number of bytes
         System.out.println("Available bytes at the beginning: " + buffer.available());

         // Reads bytes from the file
         buffer.read();
         buffer.read();
         buffer.read();

         // Returns the available number of bytes
         System.out.println("Available bytes at the end: " + buffer.available());

         buffer.close();
      }

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

Sortie

Available bytes at the beginning: 39
Available bytes at the end: 36

Dans l'exemple ci-dessus,

Nous utilisons d'abord le available() pour vérifier le nombre d'octets disponibles dans le flux d'entrée.
Ensuite, nous avons utilisé le read() méthode 3 fois pour lire 3 octets du flux d'entrée.
Maintenant, après avoir lu les octets, nous avons de nouveau vérifié les octets disponibles. Cette fois, les octets disponibles ont diminué de 3.

Méthode skip()

Pour ignorer et ignorer le nombre d'octets spécifié, nous pouvons utiliser le skip() méthode. Par exemple,

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

public class Main {

   public static void main(String args[]) {

      try {
         // Suppose, the input.txt file contains the following text
         // This is a line of text inside the file.
         FileInputStream file = new FileInputStream("input.txt");

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

         // Skips the 5 bytes
         buffer.skip(5);
         System.out.println("Input stream after skipping 5 bytes:");

         // Reads the first byte from input stream
         int i = buffer.read();
         while (i != -1) {
            System.out.print((char) i);

            // Reads next byte from the input stream
            i = buffer.read();
         }

         // Closes the input stream
         buffer.close();
      }

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

Sortie

Input stream after skipping 5 bytes: is a line of text inside the file.

Dans l'exemple ci-dessus, nous avons utilisé le skip() méthode pour ignorer 5 octets du flux d'entrée du fichier. Par conséquent, les octets 'T' , 'h' , 'i' , 's' et ' ' sont ignorés du flux d'entrée.

Méthode close()

Pour fermer le flux d'entrée tamponné, nous pouvons utiliser le close() méthode. Une fois le close() est appelée, nous ne pouvons pas utiliser le flux d'entrée pour lire les données.

Autres méthodes de BufferedInputStream

Méthodes	Descriptions
`mark()`	marquer la position dans le flux d'entrée jusqu'à laquelle les données ont été lues
`reset()`	renvoie le contrôle au point du flux d'entrée où la marque a été définie

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

Classe Java ObjectOutputStream Classe Java BufferedOutputStream

Java