Classe Java ByteArrayInputStream

Dans ce didacticiel, nous allons découvrir Java ByteArrayInputStream et ses méthodes à l'aide d'exemples.

Le ByteArrayInputStream classe du java.io package peut être utilisé pour lire un tableau de données d'entrée (en octets).

Il étend le InputStream classe abstraite.

Remarque :Dans ByteArrayInputStream , le flux d'entrée est créé à l'aide du tableau d'octets. Il comprend un tableau interne pour stocker les données de ce tableau d'octets particulier.

Créer un ByteArrayInputStream

Afin de créer un flux d'entrée de tableau d'octets, nous devons importer le java.io.ByteArrayInputStream paquet d'abord. Une fois le package importé, voici comment créer un flux d'entrée.

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

Ici, nous avons créé un flux d'entrée qui lit les données entières du arr déployer. Cependant, nous pouvons également créer le flux d'entrée qui ne lit que certaines données du tableau.

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

Ici, le flux d'entrée lit le nombre d'octets égal à longueur du tableau à partir du début poste.

Méthodes de ByteArrayInputStream

Le ByteArrayInputStream la classe fournit des implémentations pour différentes méthodes présentes dans le InputStream classe.

méthode read()

read() - lit l'octet unique du tableau présent dans le flux d'entrée
read(byte[] array) - lit les octets du flux d'entrée et les stocke dans le tableau spécifié
read(byte[] array, int start, int length) - lit le nombre d'octets égal à longueur à partir du flux et stocke dans le tableau spécifié à partir de la position début

Exemple :ByteArrayInputStream pour lire des données

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

Sortie

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

Dans l'exemple ci-dessus, nous avons créé un flux d'entrée de tableau d'octets nommé input .

ByteArrayInputStream input = new ByteArrayInputStream(array);

Ici, le flux d'entrée inclut toutes les données du tableau spécifié. Pour lire les données du flux d'entrée, nous avons utilisé le read() méthode.

méthode available()

Pour obtenir le nombre d'octets disponibles dans le flux d'entrée, nous pouvons utiliser le available() méthode. Par exemple,

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

Sortie

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

Dans l'exemple ci-dessus,

Nous avons utilisé le available() pour vérifier le nombre d'octets disponibles dans le flux d'entrée.
Nous avons ensuite utilisé le read() méthode 2 fois pour lire 2 octets du flux d'entrée.
Maintenant, après avoir lu les 2 octets, nous avons vérifié les octets disponibles. Cette fois, les octets disponibles ont diminué de 2.

Méthode skip()

Pour ignorer et ignorer le nombre d'octets spécifié, nous pouvons utiliser le skip() méthode. Par exemple,

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

Sortie

Input stream after skipping 2 bytes: 3, 4,

Dans l'exemple ci-dessus, nous avons utilisé le skip() méthode pour ignorer 2 octets de données du flux d'entrée. D'où 1 et 2 ne sont pas lus à partir du flux d'entrée.

Méthode close()

Pour fermer le flux d'entrée, nous pouvons utiliser le close() méthode.

Cependant, le close() la méthode n'a aucun effet dans ByteArrayInputStream classer. On peut utiliser les méthodes de cette classe même après le close() méthode est appelée.

Autres méthodes de ByteArrayInputStream

Méthodes	Descriptions
`finalize()`	s'assure que le `close()` la méthode est appelée
`mark()`	marque la position dans le flux d'entrée jusqu'à laquelle les données ont été lues
`reset()`	renvoie le contrôle au point du flux d'entrée où la marque a été définie
`markSupported()`	vérifie si le flux d'entrée prend en charge `mark()` et `reset()`

Pour en savoir plus, visitez Java ByteArrayInputStream (documentation officielle de Java).

Classe Java FileOutputStream Classe Java ByteArrayOutputStream

Java