Classe BufferedInputStream di Java

In questo tutorial, impareremo attraverso esempi Java BufferedInputStream e i suoi metodi.

La classe BufferedInputStream del pacchetto java.io viene utilizzata insieme ad altri stream di input per leggere dati in modo più efficace (in termini di byte).

Eredita la classe astratta InputStream.

Il funzionamento di BufferedInputStream

BufferedInputStream mantiene un8192 bytedel buffer interno.

Durante l'operazione di lettura in BufferedInputStream, si legge una parte di byte dal disco e li si memorizza in un buffer interno. E si legge ogni byte dal buffer interno.

Di conseguenza, si riduce il numero di comunicazioni con il disco. Ecco perché leggere byte con BufferedInputStream è più veloce.

Creare un BufferedInputStream

Per creare un BufferedInputStream, dobbiamo prima importare il pacchetto java.io.BufferedInputStream. Dopo aver importato il pacchetto, possiamo creare lo stream di input in questo punto.

//Crea un FileInputStream
FileInputStream file = new FileInputStream(String path);
//Crea un BufferedInputStream
BufferedInputStream buffer = new BufferedInputStream(file);

Nell'esempio sopra, abbiamo creato un buffer chiamato BufferdInputStream e abbiamo creato un file utilizzando un FileInputStream chiamato file.

In questo caso, la dimensione predefinita del buffer interno è di 8192 byte. Ma possiamo anche specificare la dimensione del buffer interno.

//Crea un BufferedInputStream con un buffer interno di dimensioni specificate
BufferedInputStream buffer = new BufferedInputStream(file, int size);

Il buffer aiuterà a leggere i byte dal file più rapidamente.

Metodi di BufferedInputStream

La classe BufferedInputStream fornisce implementazioni per diversi metodi forniti dalla classe InputStream.

Metodo read()

• read() - Legge un byte dall'input stream

• read(byte[] arr) - Legge i byte e li memorizza nell'array specificato

• read(byte[] arr, int start, int length) - Legge un numero di byte equali a length dallo stream e li memorizza nell'array specificato a partire dalla posizione start

Supponiamo di avere un file chiamatoinput.txtche contiene il seguente contenuto.

Questo è una riga di testo all'interno del file.

Proviamo a utilizzare l'input di file BufferedInputStream.

import java.io.BufferedInputStream;
import java.io.FileInputStream;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　try {
　　　　　　　　　　　　//Crea un FileInputStream
　　　　　　　　　　　　FileInputStream file = new FileInputStream("input.txt");
　　　　　　　　　　　　//Crea un BufferedInputStream
　　　　　　　　　　　　BufferedInputStream input = new BufferedInputStream(file);
　　　　　　　　　　　　//Legge il primo byte dal file
　　　　　　　　　　　　int i = input.read();
　　　　　　　　　　　　while (i != -1) {
　　　　　　　　　　　　　　　　System.out.print((char) i);
　　　　　　　　　　　　　　　　//Legge il byte successivo dal file
　　　　　　　　　　　　　　　　i = input.read();
　　　　　　　　　　　　}
　　　　　　　　　　　　input.close();
　　　　　　　　}
　　　　　　　　catch　(Exception　e)　{
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

Risultato di output

Questo è una riga di testo all'interno del file.

Nell'esempio sopra, abbiamo creato un flusso di input di buffer chiamato buffer e FileInputStream. Il flusso di input è collegato al file input.txt.

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

In questo esempio, abbiamo utilizzato il metodo read() per leggere un array di byte dal buffer del lettore.

Metodo available()

Per ottenere il numero di byte disponibili nel flusso di input, possiamo usare il metodo available(). Ad esempio

import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
　　　public static void main(String args[]) {
　　　　　　try {
　　　　　　　　//Supponiamo che il file input.txt contenga il seguente testo
　　　　　　　　//Questo è un'intera riga di testo nel file.
　　　　　　　　　FileInputStream file = new FileInputStream("input.txt");
　　　　　　　　　
　　　　　　　　　//Crea un BufferedInputStream
　　　　　　　　　BufferedInputStream buffer = new BufferedInputStream(file);
　　　　　　　　　//Restituisce il numero di byte disponibili
　　　　　　　　　System.out.println("Numero di byte disponibili all'inizio: " + buffer.available());
　　　　　　　　　//Legge byte dal file
　　　　　　　　　buffer.read();
　　　　　　　　　buffer.read();
　　　　　　　　　buffer.read();
　　　　　　　　　//Restituisce il numero di byte disponibili
　　　　　　　　　System.out.println("Numero di byte disponibili alla fine: " + buffer.available());
　　　　　　　　　buffer.close();
　　　　　　}
　　　　　　catch　(Exception　e)　{
　　　　　　　　　e.getStackTrace();
　　　　　　}
　　　}
}

Risultato di output

Numero di byte disponibili all'inizio: 39
Numero di byte disponibili alla fine: 36

Nell'esempio sopra

1. Prima di tutto, abbiamo utilizzato il metodo available() per controllare il numero di byte disponibili nel flusso di input.

2. Poi, abbiamo utilizzato il metodo read() per leggere 3 byte dal flusso di input 3 volte.

3. Ora, dopo aver letto i byte, abbiamo controllato di nuovo i byte disponibili. Questa volta i byte disponibili sono diminuiti di 3.

Metodo skip()

Per scartare e saltare il numero specificato di byte, puoi usare il metodo skip(). Ad esempio

import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
　　　public static void main(String args[]) {
　　　　　　try {
　　　　　　　　//Supponiamo che il file input.txt contenga il seguente testo
　　　　　　　　//Questo è un'intera riga di testo nel file.
　　　　　　　　　FileInputStream file = new FileInputStream("input.txt");
　　　　　　　　　//Crea un BufferedInputStream
　　　　　　　　　BufferedInputStream buffer = new BufferedInputStream(file);
　　　　　　　　　//Salta 5 byte
　　　　　　　　　buffer.skip(5);
　　　　　　　　　System.out.println("Salta 5 byte nel flusso di input:");
　　　　　　　　　//从输入流中读取第一个字节
　　　　　　　　　int i = buffer.read();
　　　　　　　　　while (i != -1) {
　　　　　　　　　　　　System.out.print((char) i);
　　　　　　　　　　　　//Leggi il prossimo byte dal flusso di input
　　　　　　　　　　　　i　=　buffer.read();
　　　　　　　　　}
　　　　　　　　　//Chiudi il flusso di input
　　　　　　　　　buffer.close();
　　　　　　}
　　　　　　catch　(Exception　e)　{
　　　　　　　　　e.getStackTrace();
　　　　　　}
　　　}
}

Risultato di output

Flusso di input dopo aver saltato 5 byte:　is　a　line　of　text　inside　the　file.

Nel esempio sopra, abbiamo utilizzato il metodo skip() per saltare 5 byte dal flusso di input di file. Pertanto, saltiamo i byte 'T', 'h', 'i', 's' e ' '.

Metodo close()

Per chiudere il flusso di input bufferizzato, possiamo utilizzare il metodo close(). Una volta chiamato il metodo close(), non possiamo più utilizzare il flusso di input per leggere i dati.

Altri metodi di BufferedInputStream