ByteArrayInputStream

ByteArrayInputStream - klassen i java.io -pakken kan bruges til at læse et input-array (af bytes).

For at oprette en byte-array-inputstrøm skal vi først importere java.io.ByteArrayInputStream -pakken. Efter at vi har importeret pakken, har vi to konstruktører til rådighed til at oprette en inputstrøm:

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

Der er 4 felter 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 vores 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 i klassen ByteArrayInputStream

Lad os se nærmere på disse metoder og se, hvordan de virker i praksis.

Læs()

Når du vil læse bytes fra en ByteArrayInputStream ligesom du ville fra en almindelig InputStream , kan du bruge 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();
   }
}
    

ledig()

Hvis du vil tjekke, om der er noget i din buffer, kan du kalde metoden available() .

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 antallet af tilgængelige bytes til læsning ændres efter hver læsning fra bufferen.

Produktion:

spring over (lang n)

Du kan bruge skip() -metoden til at springe et bestemt antal bytes over og ikke læse 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();
   }
}
    

Produktion:

Nulstil()

Denne metode nulstiller bufferstrømmens position til den sidst markerede position. Det er position 0, medmindre der er sat et andet mærke.

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 kald af reset() -metoden fører os til vores streams udgangspunkt.

Produktion:

mark(int readAheadLimit)

Mark () -metoden i klassen ByteArrayInputStream sætter det interne mærke på den aktuelle byteposition, det vil sige umiddelbart efter den tidligere læste byte. Denne metode tager en parameter, der angiver, hvor mange bytes der kan læses efter mærket, før det streamer bliver ugyldigt. Som standard, hvis mærket ikke er angivet eksplicit, markerer en ByteArrayInputStream position 0 eller positionen af ​​forskydningen videregivet til dens konstruktør. Det er vigtigt at bemærke, at readAheadLimit -mærket er irrelevant for denne klasse.

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

Her er et eksempel på indstilling af et mærke i en ByteArrayInputStream ved hjælp af dens mark() og reset() metoder. Vi tilføjer et kald til mark() -metoden til det 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 nuværende strøms position har ændret sig.

Produktion:

markSupported()

MarkSupported () -metoden lader dig kontrollere, om et mærke kan indstilles. For at forstå, hvor returværdien kommer fra, lad os gå til metodens kode:

/**
* 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 altid sand . Lad os 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();
   }
}
    

Efter at have udført mark() og reset() metoderne, er vores stream altid klar og understøtter mærker:

Produktion:

tæt()

Og for at forstå den tætte metode, lad os også tage et kig ind 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 {
}
    

Dokumentationen for lukkemetoden fortæller os, at lukning af en ByteArrayInputStream ikke har nogen effekt. Klassemetoderne ByteArrayInputStream kan kaldes efter strømmen er lukket uden at afgive en IOException .

Hvad kan vi konkludere?

Vi har brug for en ByteArrayInputStream , når vi vil læse data fra et byte-array. Det giver normalt mening at bruge denne klasse i kombination med anden kode, der ved, hvordan man arbejder med InputStreams i stedet for alene.