Clase Java BufferedInputStream

En este tutorial, aprenderemos a través de ejemplos Java BufferedInputStream y sus métodos.

La clase BufferedInputStream del paquete java.io se utiliza junto con otros flujos de entrada para leer datos de manera más eficiente (en términos de bytes).

Hereda la clase abstracta InputStream.

El mecanismo de trabajo de BufferedInputStream

BufferedInputStream mantiene un8192bytesÁrea de memoria interna.

Durante la lectura de operaciones en BufferedInputStream, se lee parte de los bytes desde el disco y se almacena en el área de memoria interna. Y se lee cada byte de manera individual desde el área de memoria interna.

Por lo tanto, se reduce el número de comunicaciones con el disco. Es por eso que leer bytes usando BufferedInputStream es más rápido.

Crear un BufferedInputStream;

Para crear un BufferedInputStream, debemos importar el paquete java.io.BufferedInputStream. Después de importar el paquete, podemos crear el flujo de entrada aquí.

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

En el ejemplo anterior, creamos un búfer llamado BufferdInputStream y lo creamos usando un FileInputStream llamado file.

Aquí, el tamaño predeterminado del búfer interno es8192Pero también podemos especificar el tamaño del búfer interno.

//Crear un BufferedInputStream con un tamaño de búfer interno especificado
BufferedInputStream buffer = new BufferInputStream(file, int size);

El buffer ayudará a leer bytes del archivo más rápido.

Métodos de BufferedInputStream

La clase BufferedInputStream proporciona implementaciones para diferentes métodos de la clase InputStream.

Método read()

• read() - Leer un byte desde el flujo de entrada

• read(byte[] arr) - Leer bytes desde el flujo y almacenarlos en el array especificado

• read(byte[] arr, int start, int length) - Leer un número de bytes igual a length desde el flujo y almacenarlos en el array especificado desde la posición start

Supongamos que tenemos un archivo llamadoinput.txtEl archivo contiene el siguiente contenido.

Esta es una línea de texto dentro del archivo.

Vamos a intentar usar el BufferedInputStream para leer el archivo.

import java.io.BufferedInputStream;
import java.io.FileInputStream;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　try {
　　　　　　　　　　　　//Crear un FileInputStream
　　　　　　　　　　　　FileInputStream file = new FileInputStream("input.txt");
　　　　　　　　　　　　//Crear un BufferedInputStream;
　　　　　　　　　　　　BufferedInputStream input = new BufferedInputStream(file);
　　　　　　　　　　　　//Leer el primer byte del archivo
　　　　　　　　　　　　int i = input.read();
　　　　　　　　　　　　while (i !=　-1) {
　　　　　　　　　　　　　　　　System.out.print((char) i);
　　　　　　　　　　　　　　　　//Leer el siguiente byte del archivo
　　　　　　　　　　　　　　　　i = input.read();
　　　　　　　　　　　　}
　　　　　　　　　　　　input.close();
　　　　　　　　}
　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

Resultado de salida

Esta es una línea de texto dentro del archivo.

En el ejemplo anterior, creamos un flujo de entrada de buffer llamado buffer y FileInputStream. El flujo de entrada está vinculado al archivo input.txt.

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

Aquí, usamos el método read() para leer un array de bytes desde el buffer del lector de缓冲.

Para obtener la cantidad de bytes disponibles en la entrada de datos, podemos usar el método available(). Por ejemplo,

import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
　　　public static void main(String args[]) {
　　　　　　try {
　　　　　　　　//Supongamos que el archivo input.txt contiene el siguiente texto
　　　　　　　　//Esta es una línea de texto dentro del archivo.
　　　　　　　　　FileInputStream file = new FileInputStream("input.txt");
　　　　　　　　　
　　　　　　　　　//Crear un BufferedInputStream;
　　　　　　　　　BufferedInputStream buffer = new BufferedInputStream(file);
　　　　　　　　　//Devuelve la cantidad de bytes disponibles
　　　　　　　　　System.out.println("Número de bytes disponibles al principio: ",　+　buffer.available());
　　　　　　　　　//Leer bytes desde el archivo
　　　　　　　　　buffer.read();
　　　　　　　　　buffer.read();
　　　　　　　　　buffer.read();
　　　　　　　　　//Devuelve la cantidad de bytes disponibles
　　　　　　　　　System.out.println("Número de bytes disponibles al final: ",　+　buffer.available());
　　　　　　　　　buffer.close();
　　　　　　}
　　　　　　catch (Exception e) {
　　　　　　　　　e.getStackTrace();
　　　　　　}
　　　}
}

Resultado de salida

Número de bytes disponibles al principio:　39
　36

En el ejemplo anterior,

1. Primero, usamos el método available() para verificar la cantidad de bytes disponibles en la entrada de datos.

2. Luego, usamos el método read()3vez desde la entrada de datos.3caracteres.

3. Ahora, después de leer los bytes, hemos revisado nuevamente los bytes disponibles. Esta vez, los bytes disponibles han disminuido3.

Método skip()

Para descartar y saltar el número especificado de bytes, se puede usar el método skip(). Por ejemplo

import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
　　　public static void main(String args[]) {
　　　　　　try {
　　　　　　　　//Supongamos que el archivo input.txt contiene el siguiente texto
　　　　　　　　//Esta es una línea de texto dentro del archivo.
　　　　　　　　　FileInputStream file = new FileInputStream("input.txt");
　　　　　　　　　//Crear un BufferedInputStream;
　　　　　　　　　BufferedInputStream buffer = new BufferedInputStream(file);
　　　　　　　　　//Saltar5caracteres;
　　　　　　　　　buffer.skip(5
　　　　　　　　　System.out.println("Saltar",5caracteres posteriores al byte:");
　　　　　　　　　//Leer el primer byte desde la entrada de datos;
　　　　　　　　　int i = buffer.read();
　　　　　　　　　while (i !=　-1) {
　　　　　　　　　　　　System.out.print((char) i);
　　　　　　　　　　　　//Leer el siguiente byte de la corriente de entrada
　　　　　　　　　　　　i = buffer.read();
　　　　　　　　　}
　　　　　　　　　//Cerrar la corriente de entrada
　　　　　　　　　buffer.close();
　　　　　　}
　　　　　　catch (Exception e) {
　　　　　　　　　e.getStackTrace();
　　　　　　}
　　　}
}

Resultado de salida

Saltar5un byte de la corriente de entrada: is a line of text inside the file.

En el ejemplo anterior, hemos utilizado el método skip() para saltar5un byte. Por lo tanto, saltamos los bytes "T", "h", "i", "s" y " " de la corriente de entrada.

Método close()

Para cerrar la corriente de entrada buffered, podemos usar el método close(). Una vez llamado el método close(), no podremos usar la corriente de entrada para leer datos.

Otros métodos de BufferedInputStream