ByteArrayInputStream

ByteArrayInputStream - klassen i java.io -pakken kan brukes til å lese en input-array (med byte).

For å lage en byte-array-inndatastrøm, må vi først importere java.io.ByteArrayInputStream -pakken. Etter at vi har importert pakken, har vi to konstruktører tilgjengelig for å lage en inngangsstrøm:

ByteArrayInputStream input = new ByteArrayInputStream(arr);
ByteArrayInputStream input = new ByteArrayInputStream(arr, 2, 2);
    

Det er 4 felt i klassen:

// Byte array provided by the creator of the stream
protected byte buf[];

// Index of the next character to read from the input stream's buffer
protected int pos;

// Current marked position in the stream
protected int mark = 0;

// Index is one greater than the last valid character in the input stream's buffer
protected int count;
    

Og her er våre konstruktører:

public ByteArrayInputStream(byte buf[]) {
    this.buf = buf;
    this.pos = 0;
    this.count = buf.length;
}

public ByteArrayInputStream(byte buf[], int offset, int length) {
    this.buf = buf;
    this.pos = offset;
    this.count = Math.min(offset + length, buf.length);
    this.mark = offset;
}
    

Metoder for ByteArrayInputStream-klassen

La oss se nærmere på disse metodene og se hvordan de fungerer i praksis.

lese()

Når du vil lese bytes fra en ByteArrayInputStream akkurat som du ville gjort fra en vanlig InputStream , kan du bruke read()- metoden.

public static void main(String[] args) {
   byte[] array = {1, 2, 3, 4};

   try (ByteArrayInputStream input = new ByteArrayInputStream(array)) {
       for (int i = 0; i < array.length; i++) {
           int data = input.read();
           System.out.print(data + ", ");
       }
   } catch (IOException e) {
       e.printStackTrace();
   }
}
    

tilgjengelig()

Hvis du vil sjekke om det er noe i bufferen din, kan du kalle tilgjengelig()- metoden.

public static void main(String[] args) {
   byte[] array = {1, 2, 3, 4};

   try (ByteArrayInputStream input = new ByteArrayInputStream(array)) {
       System.out.println("Bytes available for reading: " + input.available());

       input.read();
       System.out.println("Bytes available for reading " + input.available());

       input.read();
       System.out.println("Bytes available for reading " + input.available());
   } catch (IOException e) {
       e.printStackTrace();
   }
}
    

Vi vil se at antall byte tilgjengelig for lesing endres etter hver lesing fra bufferen.

Produksjon:

hopp over (lang n)

Du kan bruke skip()- metoden for å hoppe over et visst antall byte og ikke lese dem.

public static void main(String[] args) {
   byte[] array = {1, 2, 3, 4};

   try (ByteArrayInputStream input = new ByteArrayInputStream(array)) {
       input.skip(2);

       while (input.available() != 0) {
           int data = input.read();
           System.out.print(data + ", ");
       }
   } catch (IOException e) {
       e.printStackTrace();
   }
}
    

Produksjon:

nullstille()

Denne metoden tilbakestiller den bufrede strømmens posisjon til den sist merkede posisjonen. Det er posisjon 0 med mindre et annet merke er satt.

public static void main(String[] args) {
   byte[] buf = {65, 66, 67, 68, 69};
   try (ByteArrayInputStream input = new ByteArrayInputStream(buf)) {
       System.out.println("Read: " + input.read());
       System.out.println("Read: " + input.read());
       System.out.println("Read: " + input.read());
       System.out.println("Read: " + input.read());

       System.out.println("Calling reset() method");
       input.reset();
       System.out.println("Read: " + input.read());
       System.out.println("Read: " + input.read());
   } catch (IOException e) {
       e.printStackTrace();
   }
}
    

Vi vil se at å kalle reset()- metoden tar oss til strømmens startpunkt.

Produksjon:

mark(int readAheadLimit)

Mark () -metoden til ByteArrayInputStream- klassen setter det interne merket ved gjeldende byteposisjon, det vil si umiddelbart etter den tidligere leste byten. Denne metoden tar en parameter som indikerer hvor mange byte som kan leses etter merket før den strømmer blir ugyldig. Som standard, hvis merket ikke er angitt eksplisitt, markerer en ByteArrayInputStream posisjon 0 eller posisjonen til forskyvningen sendt til konstruktøren. Det er viktig å merke seg at readAheadLimit -merket er irrelevant for denne klassen.

/* Note: For this class, {@code readAheadLimit}
*  has no meaning.
*
* @since   1.1
*/
public void mark(int readAheadLimit) {
   mark = pos;
}
    

Her er et eksempel på å sette et merke i en ByteArrayInputStream ved å bruke metodene mark() og reset() . Vi vil legge til et kall til mark() -metoden til forrige eksempel:

public static void main(String[] args) {
   byte[] buf = {65, 66, 67, 68, 69};
   try (ByteArrayInputStream input = new ByteArrayInputStream(buf)) {
       System.out.println("Read: " + input.read());
       System.out.println("Read: " + input.read());
       System.out.println("Read: " + input.read());
       input.mark(5);

       System.out.println("Read: " + input.read());
       System.out.println("Read: " + input.read());

       System.out.println("Calling reset() method");
       input.reset();

       System.out.println("Read: " + input.read());
       System.out.println("Read: " + input.read());

   } catch (IOException e) {
       e.printStackTrace();
   }
}
    

Vi kan se at den nåværende bekkens posisjon har endret seg.

Produksjon:

markSupported()

MarkSupported () -metoden lar deg sjekke om et merke kan settes. For å forstå hvor returverdien kommer fra, la oss gå til koden til metoden:

/**
* Tests if this {@code InputStream} supports mark/reset. The
* {@code markSupported} method of {@code ByteArrayInputStream}
* always returns {@code true}.
*
* @since   1.1
*/
public boolean markSupported() {
   return true;
}
    

Metoden returnerer alltid sant . La oss teste dette i praksis.

public static void main(String[] args) {
   byte[] buf = {65, 66, 67, 68, 69};
   try (ByteArrayInputStream bais = new ByteArrayInputStream(buf)) {
       boolean isMarkSupported = bais.markSupported();

       System.out.println("isMarkSupported: " + isMarkSupported);
       System.out.println("Read: " + bais.read());
       System.out.println("Read: " + bais.read());

       bais.mark(1);
       System.out.println("Read: " + bais.read());
       isMarkSupported = bais.markSupported();
       System.out.println("isMarkSupported: " + isMarkSupported);

       bais.reset();
       isMarkSupported = bais.markSupported();
       System.out.println("isMarkSupported: " + isMarkSupported);
   } catch (IOException e) {
       e.printStackTrace();
   }
}
    

Etter å ha utført metodene mark() og reset() , er strømmen vår alltid klar og støtter merker:

Produksjon:

Lukk()

Og for å forstå lukkemetoden , la oss også ta en titt inn i den:

/**
* Closing a {@code ByteArrayInputStream} has no effect. The methods in
* this class can be called after the stream has been closed without
* generating an {@code IOException}.
*/
public void close() throws IOException {
}
    

Dokumentasjonen for lukkemetoden forteller oss at lukking av en ByteArrayInputStream ikke har noen effekt. Klassemetodene ByteArrayInputStream kan kalles etter at strømmen er stengt uten å kaste et IOException .

Hva kan vi konkludere med?

Vi trenger en ByteArrayInputStream når vi vil lese data fra en byte-array. Det er vanligvis fornuftig å bruke denne klassen i kombinasjon med annen kode som vet hvordan den fungerer med InputStreams i stedet for alene.