Klasse Java ByteArrayInputStream

In diesem Tutorial lernen wir mit Beispielen die Klasse Java ByteArrayInputStream und ihre Methoden kennen.

Die Klasse ByteArrayInputStream aus dem Paket java.io kann zur Lesung von Eingabedatenarrays (in Bytes) verwendet werden.

Es erbt von der abstrakten Klasse InputStream.

Beachtung: In ByteArrayInputStream wird ein Eingabestrom mit einem Byte-Array erstellt. Es beinhaltet ein internes Array, um die Daten des spezifischen Byte-Arrays zu speichern.

Erstelle einen ByteArrayInputStream

Um einen Byte-Array-Eingabestrom zu erstellen, müssen wir zunächst das Paket java.io.ByteArrayInputStream importieren. Nach dem Importieren des Pakets können wir den Eingabestrom erstellen.

//Erstelle einen ByteArrayInputStream, um das gesamte Array zu lesen
ByteArrayInputStream input = new ByteArrayInputStream(byte[] arr);

Hier erstellen wir einen Eingabestrom, der die gesamte Daten aus dem arr-Array liest. Aber wir können auch einen Eingabestrom erstellen, der nur einige Daten aus dem Array liest.

//Erstelle einen ByteArrayInputStream, um einen Teil des Arrays zu lesen
ByteArrayInputStream input = new ByteArrayInputStream(byte[] arr, int start, int length);

Hier beginnt der Eingabestrom ab Position start des Arrays und liest eine Anzahl von Bytes gleich der Größe length

Methoden von ByteArrayInputStream

Die Klasse ByteArrayInputStream bietet verschiedene Methoden zur Implementierung der Klasse InputStream an.

read() Methode

• read()　 - Lies ein einzelnes Byte aus dem bestehenden Array des Eingabestroms

• read(byte[] array)　 - Lies Bytes aus dem Eingabestrom und speichere sie im angegebenen Array

• read(byte[] array, int start, int length) - Lies eine Anzahl von Bytes gleich der Größe length aus dem Strom und speichert sie ab Position start im angegebenen Array

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();
　　　　}
　　}
}

Ausgaberesultat

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 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 start: ");　+　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();
　　　　}
　　}
}

Ausgaberesultat

Available byte count at the start:　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, when 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 the 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() Methode
　　　　　　input.close();
　　　　}
　　　　catch (Exception e) {
　　　　　　e.getStackTrace();
　　　　}
　　}
}

Ausgaberesultat

Überspringen2Byte nach dem Eingabestrom zu überspringen:　3,　4,

Im obigen Beispiel verwenden wir die skip()-Methode, um den Eingabestrom zu überspringen2Datenbytes. Daher wird nicht aus dem Eingabestrom gelesen1und2.

close() Methode

Um den Eingabestrom zu schließen, können Sie die close()-Methode verwenden.

Die close()-Methode funktioniert jedoch nicht in der Klasse ByteArrayInputStream. Selbst nach dem Aufruf der close()-Methode können wir die Methoden dieser Klasse verwenden.

Andere Methoden von ByteArrayInputStream