Classe Java ByteArrayInputStream

Neste tutorial, vamos aprender com exemplos o Java ByteArrayInputStream e seus métodos.

A classe ByteArrayInputStream do pacote java.io pode ser usada para ler arrays de dados de entrada (em bytes).

Ele herda a classe abstrata InputStream.

Atenção：No ByteArrayInputStream, usamos um array de bytes para criar o fluxo de entrada. Ele inclui um array interno, usado para armazenar os dados do array específico.

Criar um ByteArrayInputStream

Para criar um fluxo de entrada de array de bytes,我们必须 primeiro importar o pacote java.io.ByteArrayInputStream. Após a importação do pacote, podemos criar o fluxo de entrada.

//Criar um ByteArrayInputStream para ler o array inteiro
ByteArrayInputStream input = new ByteArrayInputStream(byte[] arr);

Aqui, criamos um fluxo de entrada que lê os dados inteiros do array arr. Mas também podemos criar um fluxo de entrada que leia apenas alguns dados do array.

//Criar um ByteArrayInputStream para ler uma parte do array
ByteArrayInputStream input = new ByteArrayInputStream(byte[] arr, int start, int length);

Aqui, o fluxo de entrada lê um número de bytes igual a length a partir da posição start do array.

Métodos do ByteArrayInputStream

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

Método read()

• read()　 - Ler um byte individual do array existente no fluxo de entrada

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

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

Example: ByteArrayInputStream reading data

import java.io.ByteArrayInputStream;
public class Main {
　　public static void main(String[] args) {
　　　　//Create a byte array
　　　　byte[] array = {1,　2,　3,　4};
　　　　try {
　　　　　　ByteArrayInputStream input = new ByteArrayInputStream(array);
　　　　　　System.out.print("Bytes read from the input stream: ");
　　　　　　for (int i = 0; i < array.length; i++) {
　　　　　　　　//Read bytes
　　　　　　　　int data = input.read();
　　　　　　　　System.out.print(data　+　"");
　　　　　　}
　　　　　　input.close();
　　　　}
　　　　catch(Exception e) {
　　　　　　e.getStackTrace();
　　　　}
　　}
}

Resultados de saída

Bytes read from the input stream:　1,　2,　3,　4,

In the above example, we created a byte array input stream named input.

ByteArrayInputStream input = new ByteArrayInputStream(array);

Here, the input stream includes all the data from the specified array. To read data from the input stream, we used the read() method.

available() method

To get the number of available bytes in the input stream, we can use the available() method. For example,

import java.io.ByteArrayInputStream;
public class Main {
　　public static void main(String args[]) {
　　　　//Create a byte array
　　　　byte[] array = {　1,　2,　3,　4　};
　　　　try {
　　　　　　ByteArrayInputStream input = new ByteArrayInputStream(array);
　　　　　　//Return the number of available bytes
　　　　　　System.out.println("Available byte count at the beginning: ");　+　input.available());
　　　　　　//Read two bytes from the input stream
　　　　　　input.read();
　　　　　　input.read();
　　　　　　//Return the number of available bytes
　　　　　　System.out.println("Available byte count at the end: ");　+　input.available());
　　　　　　input.close();
　　　　}
　　　　catch (Exception e) {
　　　　　　e.getStackTrace();
　　　　}
　　}
}

Resultados de saída

Available byte count at the beginning:　4
Available byte count at the end:　2

In the above example,

1. We have used the available() method to check the number of available bytes in the input stream.

2. Then, we use the read() method2time from the input stream2bytes.

3. Now, in reading2bytes after, we checked the available bytes. This time, the available bytes decreased2.

skip() method

To discard and skip specified bytes, you can use the skip() method. For example

import java.io.ByteArrayInputStream;
public class Main {
　　public static void main(String args[]) {
　　　　//Create a byte array
　　　　byte[] array = {　1,　2,　3,　4　};
　　　　try {
　　　　　　ByteArrayInputStream input = new ByteArrayInputStream(array);
　　　　　　//Using skip() method
　　　　　　input.skip(2);
　　　　　　System.out.print("Skip ");2bytes after the input stream: ");
　　　　　　int data = input.read();
　　　　　　while (data !=　-1) {
　　　　　　　　System.out.print(data　+　"");
　　　　　　　　data = input.read();
　　　　　　}
　　　　　　//　close() método
　　　　　　input.close();
　　　　}
　　　　catch (Exception e) {
　　　　　　e.getStackTrace();
　　　　}
　　}
}

Resultados de saída

Pular2bytes para o fluxo de entrada:　3,　4,

No exemplo acima, usamos o método skip() para pular o fluxo de entrada de2Os dados de bytes. Portanto, não serão lidos do fluxo de entrada1E2.

Método close()

Para fechar o fluxo de entrada, você pode usar o método close().

No entanto, o método close() não funciona na classe ByteArrayInputStream. Mesmo após a chamada do método close(), podemos usar os métodos dessa classe.

Outros métodos de ByteArrayInputStream