Java ByteArrayInputStream Class

In deze zelfstudie leren we over Java ByteArrayInputStream en zijn methoden met behulp van voorbeelden.

De ByteArrayInputStream klasse van de java.io pakket kan worden gebruikt om een ​​reeks invoergegevens (in bytes) te lezen.

Het verlengt de InputStream abstracte klas.

Opmerking :In ByteArrayInputStream , wordt de invoerstroom gemaakt met behulp van de array van bytes. Het bevat een interne array om gegevens van die specifieke bytearray op te slaan.

Maak een ByteArrayInputStream

Om een ​​bytearray-invoerstroom te maken, moeten we de java.io.ByteArrayInputStream . importeren pakket eerst. Zodra we het pakket hebben geïmporteerd, kunnen we als volgt een invoerstroom maken.

// Creates a ByteArrayInputStream that reads entire array
ByteArrayInputStream input = new ByteArrayInputStream(byte[] arr);

Hier hebben we een invoerstroom gemaakt die volledige gegevens leest van de arr reeks. We kunnen echter ook de invoerstroom maken die slechts enkele gegevens uit de array leest.

// Creates a ByteArrayInputStream that reads a portion of array
ByteArrayInputStream input = new ByteArrayInputStream(byte[] arr, int start, int length);

Hier leest de invoerstroom het aantal bytes gelijk aan lengte uit de array beginnend bij de start positie.

Methoden van ByteArrayInputStream

De ByteArrayInputStream class biedt implementaties voor verschillende methoden die aanwezig zijn in de InputStream klasse.

read()-methode

• read() - leest de enkele byte uit de array die aanwezig is in de invoerstroom
• read(byte[] array) - leest bytes uit de invoerstroom en slaat op in de opgegeven array
• read(byte[] array, int start, int length) - leest het aantal bytes gelijk aan lengte uit de stream en slaat op in de opgegeven array vanaf de positie start

Voorbeeld:ByteArrayInputStream om gegevens te lezen

import java.io.ByteArrayInputStream;

public class Main {
  public static void main(String[] args) {

    // Creates an array of byte
    byte[] array = {1, 2, 3, 4};

    try {
      ByteArrayInputStream input = new ByteArrayInputStream(array);

      System.out.print("The bytes read from the input stream: ");

      for(int i= 0; i < array.length; i++) {

        // Reads the bytes
        int data = input.read();
        System.out.print(data + ", ");
      }
      input.close();
    }

    catch(Exception e) {
      e.getStackTrace();
    }
  }
}

Uitvoer

The bytes read from the input stream: 1, 2, 3, 4,

In het bovenstaande voorbeeld hebben we een bytearray-invoerstroom gemaakt met de naam input .

ByteArrayInputStream input = new ByteArrayInputStream(array);

Hier bevat de invoerstroom alle gegevens van de opgegeven array. Om gegevens uit de invoerstroom te lezen, hebben we de read() . gebruikt methode.

beschikbare() methode

Om het aantal beschikbare bytes in de invoerstroom te krijgen, kunnen we de available() . gebruiken methode. Bijvoorbeeld,

import java.io.ByteArrayInputStream;

public class Main {

  public static void main(String args[]) {

    // Creates an array of bytes
    byte[] array = { 1, 2, 3, 4 };

    try {
      ByteArrayInputStream input = new ByteArrayInputStream(array);

      // Returns the available number of bytes
      System.out.println("Available bytes at the beginning: " + input.available());

      // Reads 2 bytes from the input stream
      input.read();
      input.read();

      // Returns the available number of bytes
      System.out.println("Available bytes at the end: " + input.available());

      input.close();
    }

    catch (Exception e) {
      e.getStackTrace();
    }
  }
}

Uitvoer

Available bytes at the beginning: 4
Available bytes at the end: 2

In het bovenstaande voorbeeld,

1. We hebben de available() . gebruikt methode om het aantal beschikbare bytes in de invoerstroom te controleren.
2. We hebben toen de read() . gebruikt methode 2 keer om 2 bytes uit de invoerstroom te lezen.
3. Nu, na het lezen van de 2 bytes, hebben we de beschikbare bytes gecontroleerd. Deze keer zijn de beschikbare bytes met 2 afgenomen.

skip()-methode

Om het opgegeven aantal bytes te negeren en over te slaan, kunnen we de skip() . gebruiken methode. Bijvoorbeeld,

import java.io.ByteArrayInputStream;

public class Main {

  public static void main(String args[]) {

    // Create an array of bytes
    byte[] array = { 1, 2, 3, 4 };
    try {
      ByteArrayInputStream input = new ByteArrayInputStream(array);

      // Using the skip() method
      input.skip(2);
      System.out.print("Input stream after skipping 2 bytes: ");

      int data = input.read();
      while (data != -1) {
        System.out.print(data + ", ");
        data = input.read();
      }

      // close() method
      input.close();
    }

    catch (Exception e) {
      e.getStackTrace();
    }
  }
}

Uitvoer

Input stream after skipping 2 bytes: 3, 4,

In het bovenstaande voorbeeld hebben we de skip() . gebruikt methode om 2 bytes aan gegevens uit de invoerstroom over te slaan. Vandaar 1 en 2 worden niet uit de invoerstroom gelezen.

close()-methode

Om de invoerstroom te sluiten, kunnen we de close() . gebruiken methode.

Echter, de close() methode heeft geen effect in ByteArrayInputStream klas. We kunnen de methoden van deze klasse zelfs gebruiken na de close() methode wordt aangeroepen.

Andere methoden van ByteArrayInputStream

Ga voor meer informatie naar Java ByteArrayInputStream (officiële Java-documentatie).