ByteArrayInputStream

Ang klase ng ByteArrayInputStream sa java.io package ay maaaring gamitin upang magbasa ng input array (ng mga byte).

Para gumawa ng byte array input stream, kailangan muna nating i-import ang java.io.ByteArrayInputStream package. Pagkatapos naming i-import ang package, mayroon kaming dalawang constructor na magagamit para sa paglikha ng input stream:

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

Mayroong 4 na field sa loob ng klase:

// 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;

At narito ang aming mga tagabuo:

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

Mga pamamaraan ng klase ng ByteArrayInputStream

Tingnan natin ang mga pamamaraang ito at tingnan kung paano gumagana ang mga ito sa pagsasanay.

basahin()

Kapag gusto mong magbasa ng mga byte mula sa isang ByteArrayInputStream tulad ng gagawin mo mula sa isang ordinaryong InputStream , maaari mong gamitin ang read() na paraan.

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

magagamit()

Kung gusto mong suriin kung mayroong isang bagay sa iyong buffer, maaari mong tawagan ang available() na paraan.

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

Makikita natin na ang bilang ng mga byte na magagamit para sa pagbabasa ay nagbabago pagkatapos ng bawat pagbabasa mula sa buffer.

Output:

laktawan (mahaba n)

Maaari mong gamitin ang pamamaraan ng skip() upang laktawan ang isang tiyak na bilang ng mga byte at hindi basahin ang mga ito.

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

Output:

i-reset()

Nire-reset ng pamamaraang ito ang posisyon ng buffered stream sa huling minarkahang posisyon. Ito ay posisyon 0 maliban kung ibang marka ang nakatakda.

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

Makikita natin na ang pagtawag sa reset() na paraan ay magdadala sa atin sa simula ng ating stream.

Output:

markahan(int readAheadLimit)

Itinatakda ng mark() na paraan ng klase ng ByteArrayInputStream ang panloob na marka sa kasalukuyang posisyon ng byte, iyon ay, kaagad pagkatapos ng naunang nabasang byte. Ang pamamaraang ito ay tumatagal ng isang parameter na nagsasaad kung gaano karaming mga byte ang mababasa pagkatapos ng marka bago ito maging di-wasto. Bilang default, kung ang marka ay hindi tahasang nakatakda, ang isang ByteArrayInputStream ay nagmamarka ng posisyon 0 o ang posisyon ng offset na ipinasa sa constructor nito. Mahalagang tandaan na ang readAheadLimit mark ay walang kaugnayan para sa klase na ito.

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

Narito ang isang halimbawa ng pagtatakda ng marka sa isang ByteArrayInputStream gamit ang mark() at reset() na pamamaraan nito. Magdaragdag kami ng isang tawag sa mark() na pamamaraan sa nakaraang halimbawa:

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

Makikita natin na nagbago ang posisyon ng kasalukuyang stream.

Output:

markSupported()

Ang markSupported() na pamamaraan ay nagbibigay-daan sa iyong suriin kung ang isang marka ay maaaring itakda. Upang maunawaan kung saan nagmumula ang return value, pumunta tayo sa code ng pamamaraan:

/**
* 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;
}

Ang pamamaraan ay palaging nagbabalik ng totoo . Subukan natin ito sa pagsasanay.

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

Pagkatapos isagawa ang mark() at reset() na mga pamamaraan, ang aming stream ay laging handa at sumusuporta sa mga marka:

Output:

malapit ()

At upang maunawaan ang malapit na pamamaraan, tingnan din natin ang loob nito:

/**
* 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 {
}

Ang dokumentasyon para sa malapit na paraan ay nagsasabi sa amin na ang pagsasara ng isang ByteArrayInputStream ay walang epekto. Ang mga pamamaraan ng klase ng ByteArrayInputStream ay maaaring tawagin pagkatapos isara ang stream nang hindi naghagis ng IOException .

Ano ang masasabi natin?

Kailangan namin ng ByteArrayInputStream kapag gusto naming magbasa ng data mula sa isang byte array. Karaniwang makatuwirang gamitin ang klase na ito kasama ng iba pang code na nakakaalam kung paano gumana sa InputStreams sa halip na mag-isa.