JavaByteArrayInputStream

La classe ByteArrayInputStream est composée de deux phases : Byte Array et une pour Input Stream. Byte Array joue un rôle central dans la conservation des données importantes et des octets nécessaires par rapport au flux d'entrée. La classe Java ByteArrayInputStream comprend le tampon interne, qui est responsable de la lecture du tableau d'octets sous forme de flux. Le tableau d'octets transmet les données à alimenter en tant que flux d'entrée. Ces données, lorsqu'elles sont présentes dans le tampon, sont augmentées. La traversée et la récupération des données deviennent flexibles et transparentes grâce à cette classe.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe :

public class ByteArrayInputStream extends InputStream

Dans le cadre de Java ByteArrayInputStream, le flux d'exécution est le suivant :

Une classe publique de ByteArrayInputStream est déclarée, qui étend l'interface en tant que support pour interagir avec le flux mis avec InputStream.

Comment fonctionne la classe ByteArrayInputStream en Java ?

Le fonctionnement de ByteArrayInputStream est assez simple, dont le principe principal est de convertir le tableau d'octets en flux d'entrée de manière transparente. Comme avantage supplémentaire de cette classe, le tampon garantit que le package java.io.ByteArrayInput constitué de l'API vous permet de lire les données des tableaux d'octets en tant que flux du tableau d'octets, qui sont ensuite transformés en flux d'entrée, qui sera être introduit dans le tampon. Le ByteArrayInputstream est une sous-classe de la classe InputStream. Par conséquent, le ByteArrayInputStream peut être utilisé comme InputStream. Si les données sont organisées et stockées dans un tableau en tant que flux d'entrée, elles peuvent être encapsulées dans un tableau d'octets et se transformer facilement en flux. Une fois l'objet ByteArrayInputStream prêt, une liste de méthodes d'assistance peut être utilisée pour lire et effectuer des opérations sur le flux.

Constructeur de Java ByteArrayInputStream

Les constructeurs suivants sont utilisés pour prendre en charge la classe ByteArrayInputStream de Java.

ByteArrayInputStream[byte a]

Dans le cadre de Java ByteArrayInputStream, ce constructeur fonctionne d'une manière qui est utilisée pour accepter un ensemble préparé du tableau d'octets, notamment en tant que paramètre dans la mémoire du tampon interne présent dans le cadre du package et de la classe.

ByteArrayInputStream(byte [] a, int off, int len)

Ce constructeur faisant partie de la classe Java ByteArrayInputStream transmet trois arguments en tant que paramètre du flux, qui prend en compte le tableau d'octets, l'entier et la longueur de l'entier défini, et le flux maintient également l'ordre lorsqu'il est alimenté en tant que entrée dans la mémoire du tampon ce qui signifie que d'abord le tableau d'octets a[], puis deux valeurs entières où off Est le premier octet à lire suivi de la longueur du nombre d'octets à lire.

Méthodes de Java ByteArrayInputStream

Vous trouverez ci-dessous les méthodes de Java ByteArrayInputStream :

1. public int read()
2. public int read(byte[] r, int off, int len)
3. int public disponible()
4. marque vide publique (lecture int)
5. saut long public (long n)
6. mark booléen publicSupported()
7. réinitialisation du vide public()
8. public void close()

1. public int read()

Cette méthode fait partie de la classe ByteArrayInputStream et est utilisée pour lire l'octet suivant disponible dans le flux d'entrée déjà en cours, qui renvoie un type int de plage 0-255. S'il n'y a aucun octet présent dans le tampon comme flux d'entrée, il est revenu à la fin du flux, qui renvoie -1 comme valeur.

2. public int read(byte[] r, int off, int len)

Cette méthode lit les octets jusqu'à la longueur du nombre d'octets à partir du flux d'entrée dans un tableau et renvoie le nombre total d'octets jusqu'à ce que le dernier octet de -1 soit renvoyé.

3. public int disponible()

Dans le cadre de la classe ByteArrayInputStream, cette méthode est utilisée pour lire et reconnaître le nombre total d'octets qui seront disponibles à partir du flux d'entrée à lire.

4. marque vide publique (int read)

Dans le cadre de la classe ByteArrayInputStream, cette méthode est utilisée pour marquer et définir la position actuelle du flux d'entrée. Fondamentalement, il définit une limite de lecture pour obtenir le nombre maximum d'octets pouvant être lus avant que la limite marquée ne devienne invalide.

5. saut long public (long n)

Dans le cadre de la classe ByteArrayInputStream, cette méthode est utilisée pour ignorer le nombre d'octets dans le flux d'entrée comme argument de la méthode.

6. public boolean markSupported()

Cette méthode est utilisée pour tester le flux d'entrée s'il prend en charge la limite marquée ou s'il fonctionne sans sa présence. Il a une particularité qui, chaque fois que cette marque est prise en charge, est utilisée comme méthode ; il renvoie une valeur toujours vraie.

7. public void reset()

This method is used to reset the position of the marker as it is provoked by the mark() method. The added advantage is to reposition and reset the marker for traversing.

8. public void close()

This method plays a crux to release all the resources once close. When It gets called, the input stream gets closed, and the stream gets associated with the garbage collector.

Examples to Implement of Java ByteArrayInputStream

Below are the examples of Java ByteArrayInputStream:

Example #1

This program is used to illustrate the read() method byte by byte in ByteArrayInputStream.

Code:

import java.io.*;
public class Input_Buffer_Stream1 {
public static void main(String[] args) throws Exception {
byte guava = 0;
byte pine = 0;
byte kiwi = 0;
byte orange = 0;
byte[] buffr = {guava, pine, kiwi,orange};
ByteArrayInputStream fruits = new ByteArrayInputStream(buffr);
int k = 0;
while((k=fruits.read())!=-1) {
System.out.println("These fruits are really tasty and relising to have & Its the time to have ad enjoy!");
}
}
}

Output:

Example #2

This program illustrates the available method of ByteArrayInputStream.

Code :

import java.io.ByteArrayInputStream;
public class Input_Buffer_Stream2 {
public static void main(String[] args) {
byte[] buffr= {20,22};
ByteArrayInputStream bytes = new ByteArrayInputStream(buffr);
int bytes_Available = bytes.available();
System.out.println("no of bytes available:" + bytes_Available);
}
}

Output:

Example #3

This program illustrates the mark method of the ByteArrayInputStream class.

Code:

import java.io.ByteArrayInputStream;
public class Input_Buffer_Stream3 {
public static void main(String[] args) {
byte[] buffr= {20,22,19,10};
ByteArrayInputStream bytes_arr = new ByteArrayInputStream(buffr);
bytes_arr.mark(0);
System.out.println("These are the marked bytes of the stream:" + bytes_arr);
}
}

Output:

Example #4

This program illustrates the skip method of the ByteArrayInputStream class.

Code :

import java.io.ByteArrayInputStream;
public class Input_Buffer_Stream4 {
public static void main(String[] args) throws Exception {
byte[] buffr= {20,22,18,10};
ByteArrayInputStream learning = null;
learning = new ByteArrayInputStream(buffr);
long num = learning.skip(1);
System.out.println("Char : "+(char)learning.read());
}
}

Output:

Example #5

This program illustrates the boolean mark supported method of the ByteArrayInputStream class.

Code :

import java.io.ByteArrayInputStream;
public class Input_Buffer_Stream_5 {
public static void main(String[] args) {
byte[] buff = {15, 18, 20, 40, 52};
ByteArrayInputStream educba = null;
educba = new ByteArrayInputStream(buff);
boolean checker = educba.markSupported();
System.out.println("\n mark is supported for : "+ checker );
}
}

Output:

Example #6

This program illustrates the presence of boolean mark, reset, and close method of the ByteArrayInputStream class.

Code:

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class Input_Buffer_Stream_5 {
public static void main(String[] args) {
byte[] buff = {15, 18, 20, 40, 52};
ByteArrayInputStream educba = null;
educba = new ByteArrayInputStream(buff);
boolean checker = educba.markSupported();
System.out.println("\n mark is supported for : "+ checker );
if(educba.markSupported())
{
educba.reset();
System.out.println("\n supports for the marking limit once reset");
System.out.println("Char : "+(char)educba.read());
}
else
{
System.out.println("It is not supporting the positioning using reset method");
}
System.out.println("educba.markSupported() supported reset() : "+checker);
if(educba!=null)
{
try {
educba.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
} <strong>Output:</strong>

Conclusion

Java ByteArrayInputStream is a class that has a lot of capability and versatility to play around with the arrays in the internal buffer, which is the beauty of the class. It does not require any external class or plugin to support its base methods which work with a lot of functionality. ByteArrayInputStream together forms a perfect combination to feed the input and output stream related data.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!