Classe Java BufferedInputStream
Classe Java BufferedInputStream
Neste tutorial, aprenderemos sobre o Java BufferedInputStream e seus métodos com a ajuda de exemplos.
O BufferedInputStream classe do java.io O pacote é usado com outros fluxos de entrada para ler os dados (em bytes) com mais eficiência.
Ele estende o InputStream classe abstrata.
Funcionamento de BufferedInputStream
O
BufferedInputStream mantém um buffer interno de 8192 bytes . Durante a operação de leitura em
BufferedInputStream , um pedaço de bytes é lido do disco e armazenado no buffer interno. E dos bytes do buffer interno são lidos individualmente. Assim, o número de comunicação com o disco é reduzido. É por isso que a leitura de bytes é mais rápida usando o
BufferedInputStream . Criar um BufferedInputStream
Para criar um
BufferedInputStream , devemos importar o java.io.BufferedInputStream pacote primeiro. Uma vez que importamos o pacote, aqui é como podemos criar o fluxo de entrada.
// Creates a FileInputStream
FileInputStream file = new FileInputStream(String path);
// Creates a BufferedInputStream
BufferedInputStream buffer = new BufferInputStream(file);
No exemplo acima, criamos um
BufferdInputStream chamado buffer com o FileInputStream chamado arquivo . Aqui, o buffer interno tem o tamanho padrão de 8192 bytes. No entanto, também podemos especificar o tamanho do buffer interno.
// Creates a BufferedInputStream with specified size internal buffer
BufferedInputStream buffer = new BufferInputStream(file, int size);
O buffer ajudará a ler os bytes dos arquivos mais rapidamente.
Métodos de BufferedInputStream
O
BufferedInputStream classe fornece implementações para diferentes métodos presentes no InputStream classe. Método read()
read()- lê um único byte do fluxo de entradaread(byte[] arr)- lê bytes do fluxo e armazena no array especificadoread(byte[] arr, int start, int length)- lê o número de bytes igual ao comprimento do stream e armazena no array especificado a partir da posição start
Suponha que temos um arquivo chamado input.txt com o seguinte conteúdo.
This is a line of text inside the file.
Vamos tentar ler o arquivo usando
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();
}
}
}
Saída
This is a line of text inside the file.
No exemplo acima, criamos um fluxo de entrada em buffer chamado buffer juntamente com
FileInputStream . O fluxo de entrada está vinculado ao arquivo input.txt .
FileInputStream file = new FileInputStream("input.txt");
BufferedInputStream buffer = new BufferedInputStream(file);
Aqui, usamos o
read() método para ler uma matriz de bytes do buffer interno do leitor em buffer. Método available()
Para obter o número de bytes disponíveis no fluxo de entrada, podemos usar o
available() método. Por exemplo,
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();
}
}
}
Saída
Available bytes at the beginning: 39 Available bytes at the end: 36
No exemplo acima,
- Primeiro usamos o
available()método para verificar o número de bytes disponíveis no fluxo de entrada. - Então, usamos o
read()método 3 vezes para ler 3 bytes do fluxo de entrada. - Agora, depois de ler os bytes, verificamos novamente os bytes disponíveis. Desta vez, os bytes disponíveis diminuíram em 3.
Método skip()
Para descartar e pular o número especificado de bytes, podemos usar o
skip() método. Por exemplo,
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();
}
}
}
Saída
Input stream after skipping 5 bytes: is a line of text inside the file.
No exemplo acima, usamos o
skip() método para pular 5 bytes do fluxo de entrada do arquivo. Portanto, os bytes 'T' , 'h' , 'i' , 's' e ' ' são ignorados do fluxo de entrada. método close()
Para fechar o fluxo de entrada em buffer, podemos usar o
close() método. Uma vez que o close() é chamado, não podemos usar o fluxo de entrada para ler os dados. Outros métodos de BufferedInputStream
| Métodos | Descrições |
|---|---|
mark() | marcar a posição no fluxo de entrada até a qual os dados foram lidos |
reset() | retorna o controle ao ponto no fluxo de entrada onde a marca foi definida |
Para saber mais, visite Java BufferdInputStream (documentação oficial do Java).
Java