Classe Java BufferedInputStream

Neste tutorial, vamos aprender o Java BufferedInputStream e seus métodos através de exemplos.

A classe BufferedInputStream do pacote java.io é usada junto com outros fluxos de entrada para ler dados de maneira mais eficiente (em unidades de bytes).

Ele herda a classe abstrata InputStream.

O mecanismo de funcionamento do BufferedInputStream

BufferedInputStream mantém um8192bytesárea de buffer interna.

Durante a operação de leitura no BufferedInputStream, parte dos bytes é lidos do disco e armazenados em uma área de buffer interna. E cada byte é lido a partir da área de buffer interna.

Portanto, reduz o número de comunicações com o disco. É por isso que usar BufferedInputStream para ler bytes é mais rápido.

Criar um BufferedInputStream

Para criar um BufferedInputStream, devemos primeiro importar o pacote java.io.BufferedInputStream. Após a importação do pacote, podemos criar o fluxo de entrada aqui.

//Criar um FileInputStream
FileInputStream file = new FileInputStream(String path);
//Criar um BufferedInputStream
BufferedInputStream buffer = new BufferedInputStream(file);

No exemplo acima, criamos um buffer chamado BufferdInputStream e usamos um FileInputStream chamado file para criar um arquivo.

Aqui, o tamanho padrão do buffer interno é8192Os bytes. Mas, também podemos especificar o tamanho do buffer interno.

//Criar um BufferedInputStream com um buffer interno de tamanho especificado
BufferedInputStream buffer = new BufferedInputStream(file, int size);

O buffer ajudará a ler bytes do arquivo mais rapidamente.

Métodos da BufferedInputStream

A classe BufferedInputStream fornece implementações para diferentes métodos da classe InputStream.

Método read()

• read() - Ler um byte do fluxo de entrada

• read(byte[] arr) - Ler bytes do fluxo e armazená-los no array especificado

• read(byte[] arr, int start, int length) - Ler um número de bytes igual a length a partir do fluxo e armazenar no array especificado a partir da posição start

Suponha que tenhamos um arquivo chamadoinput.txtcontendo o seguinte conteúdo.

Esta é uma linha de texto dentro do arquivo.

Vamos tentar usar o BufferedInputStream para ler o arquivo.

import java.io.BufferedInputStream;
import java.io.FileInputStream;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　try {
　　　　　　　　　　　　//Criar um FileInputStream
　　　　　　　　　　　　FileInputStream file = new FileInputStream("input.txt");
　　　　　　　　　　　　//Criar um BufferedInputStream
　　　　　　　　　　　　BufferedInputStream input = new BufferedInputStream(file);
　　　　　　　　　　　　//Ler o primeiro byte do arquivo
　　　　　　　　　　　　int i = input.read();
　　　　　　　　　　　　while (i !=　-1) {
　　　　　　　　　　　　　　　　System.out.print((char) i);
　　　　　　　　　　　　　　　　//Ler o próximo byte do arquivo
　　　　　　　　　　　　　　　　i = input.read();
　　　　　　　　　　　　}
　　　　　　　　　　　　input.close();
　　　　　　　　}
　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

Resultados de Saída

Esta é uma linha de texto dentro do arquivo.

No exemplo acima, criamos um fluxo de entrada de buffer chamado buffer e FileInputStream. O fluxo de entrada está conectado ao arquivo input.txt.

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

Aqui, usamos o método read() para ler um array de bytes do buffer interno do leitor de buffer.

Para obter o número de bytes disponíveis no fluxo de entrada, podemos usar o método available(). Por exemplo,

import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
　　　public static void main(String args[]) {
　　　　　　try {
　　　　　　　　//Supondo que o arquivo input.txt contenha o seguinte texto
　　　　　　　　//Esta é uma linha de texto no arquivo.
　　　　　　　　　FileInputStream file = new FileInputStream("input.txt");
　　　　　　　　　
　　　　　　　　　//Criar um BufferedInputStream
　　　　　　　　　BufferedInputStream buffer = new BufferedInputStream(file);
　　　　　　　　　//Retorna o número de bytes disponíveis
　　　　　　　　　System.out.println("Número de bytes disponíveis no início: ",　+　buffer.available());
　　　　　　　　　//Ler bytes do arquivo
　　　　　　　　　buffer.read();
　　　　　　　　　buffer.read();
　　　　　　　　　buffer.read();
　　　　　　　　　//Retorna o número de bytes disponíveis
　　　　　　　　　System.out.println("Número de bytes disponíveis no final: ",　+　buffer.available());
　　　　　　　　　buffer.close();
　　　　　　}
　　　　　　catch (Exception e) {
　　　　　　　　　e.getStackTrace();
　　　　　　}
　　　}
}

Resultados de Saída

Número de bytes disponíveis no início:　39
　36

No exemplo acima,

1. Primeiro, usamos o método available() para verificar o número de bytes disponíveis no fluxo de entrada.

2. Em seguida, usamos o método read()3vezes lendo do fluxo de entrada3bytes.

3. Agora, após a leitura dos bytes, verificamos novamente o número de bytes disponíveis. Desta vez, o número de bytes disponíveis diminuiu3.

Método skip()

Para descartar e pular o número especificado de bytes, você pode usar o método skip(). Por exemplo

import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
　　　public static void main(String args[]) {
　　　　　　try {
　　　　　　　　//Supondo que o arquivo input.txt contenha o seguinte texto
　　　　　　　　//Esta é uma linha de texto no arquivo.
　　　　　　　　　FileInputStream file = new FileInputStream("input.txt");
　　　　　　　　　//Criar um BufferedInputStream
　　　　　　　　　BufferedInputStream buffer = new BufferedInputStream(file);
　　　　　　　　　//Pular5bytes;
　　　　　　　　　buffer.skip(5
　　　　　　　　　System.out.println("Pular",5depois de um byte:");
　　　　　　　　　//Ler o primeiro byte do fluxo de entrada:
　　　　　　　　　int i = buffer.read();
　　　　　　　　　while (i !=　-1) {
　　　　　　　　　　　　System.out.print((char) i);
　　　　　　　　　　　　//Ler o próximo byte do fluxo de entrada
　　　　　　　　　　　　i = buffer.read();
　　　　　　　　　}
　　　　　　　　　//Fechar o Fluxo de Entrada
　　　　　　　　　buffer.close();
　　　　　　}
　　　　　　catch (Exception e) {
　　　　　　　　　e.getStackTrace();
　　　　　　}
　　　}
}

Resultados de Saída

Pular5bytes do fluxo de entrada após o is: é uma linha de texto dentro do arquivo.

No exemplo acima, usamos o método skip() para pular5bytes. Portanto, pular os bytes 'T', 'h', 'i', 's' e ' ' do fluxo de entrada.

Método close()

Para fechar o fluxo de entrada com buffer, podemos usar o método close(). Assim que o método close() for chamado, não poderemos mais usar o fluxo de entrada para ler dados.

Outros Métodos de BufferedInputStream