Dans ce didacticiel, nous allons découvrir Java BufferedInputStream et ses méthodes à l'aide d'exemples.
La BufferedInputStreamclasse du java.iopackage est utilisée avec d'autres flux d'entrée pour lire les données (en octets) plus efficacement.
Il étend la InputStreamclasse abstraite.
Fonctionnement de BufferedInputStream
Le BufferedInputStreammaintient une mémoire tampon interne de 8192 octets .
Pendant l'opération de lecture dans 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 avec 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, nous devons d'abord importer le java.io.BufferedInputStreampackage. 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 BufferdInputStreamtampon nommé avec le FileInputStreamfichier nommé.
Ici, la mémoire 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 les octets des fichiers plus rapidement.
Méthodes de BufferedInputStream
La BufferedInputStreamclasse fournit des implémentations pour différentes méthodes présentes dans la InputStreamclasse.
read (), méthode
read()- lit un seul octet dans le flux d'entréeread(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 du flux et stocke dans le tableau spécifié à partir de la position de 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(); ) ) )
Production
Il s'agit d'une ligne de texte à l'intérieur du fichier.
Dans l'exemple ci-dessus, nous avons créé un flux d'entrée tamponné 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é la read()méthode pour lire un tableau d'octets à partir du tampon interne du lecteur tamponné.
available () Méthode
Pour obtenir le nombre d'octets disponibles dans le flux d'entrée, nous pouvons utiliser la 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(); ) ) )
Production
Octets disponibles au début: 39 Octets disponibles à la fin: 36
Dans l'exemple ci-dessus,
- Nous utilisons d'abord la
available()méthode pour vérifier le nombre d'octets disponibles dans le flux d'entrée. - Ensuite, nous avons utilisé la
read()méthode 3 fois pour lire 3 octets dans le flux d'entrée. - Maintenant, après avoir lu les octets, nous avons à nouveau vérifié les octets disponibles. Cette fois, les octets disponibles ont diminué de 3.
skip (), méthode
Pour supprimer et ignorer le nombre d'octets spécifié, nous pouvons utiliser la 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(); ) ) )
Production
Flux d'entrée après avoir sauté 5 octets: est une ligne de texte à l'intérieur du fichier.
Dans l'exemple ci-dessus, nous avons utilisé la skip()méthode pour sauter 5 octets du flux d'entrée du fichier. Par conséquent, les octets 'T', 'h', 'i', 's'et ' 'sont ignorées dans le flux d'entrée.
close (), méthode
Pour fermer le flux d'entrée tamponné, nous pouvons utiliser la close()méthode. Une fois la close()méthode 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 Java officielle).
