ByteArrayInputStream

ByteArrayInputStream klassi java.io paketdan kirish (baytlarda) ma'lumotlari massivini o'qish uchun ishlatilishi mumkin.

Baytli ma'lumotlar oqimini yaratish uchun avvalo java.io.ByteArrayInputStream paketini import qilishimiz kerak. Paketni import qilganimizdan so'ng, oqimni yaratish uchun ikki konstruktor mavjud:

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

Klass ichida 4 ta maydon mavjud:

//Potok yaratuvchisi tomonidan taqdim etilgan baytlar massivi
protected byte buf[];

//Kirish oqimi buferidan keyingi o'qiladigan belgining indeksi
protected int pos;

//Potokdagi joriy belgilanadigan pozitsiya
protected int mark = 0;

//Kirish oqim boferida ruxsat etilgan oxirgi belginsondan birga katta bo'lgan indeks
protected int count;
    

Konstruktorlarimiz mana bunday:

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

ByteArrayInputStream metodlari

Keling, ushbu metodlarni batafsil ko'rib chiqamiz va ular amalda qanday ishlashini ko'rib chiqamiz.

read()

Agar siz ByteArrayInputStream dan baytlarni odatdagi InputStream dan o'qigandek o'qishingiz kerak bo'lsa, read() metodidan foydalanishingiz mumkin.

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

available()

Agar siz buferingizda nimadir bor-yo'qligini tekshirmoqchi bo'lsangiz, available() metodini chaqirishingiz mumkin.

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

   try (ByteArrayInputStream input = new ByteArrayInputStream(array)) {
       System.out.println("o'qish uchun mavjud baytlar " + input.available());

       input.read();
       System.out.println("o'qish uchun bo'sh baytlar " + input.available());

       input.read();
       System.out.println("o'qish uchun bo'sh baytlar " + input.available());
   } catch (IOException e) {
       e.printStackTrace();
   }
}
    

Natijada, har bir o'qishdan keyin buferdan o'qilishi mumkin bo'lgan mavjud baytlar soni o'zgarishini ko'ramiz.

Dastur chiqishi:

skip(long n)

skip() metodi orqali siz ma'lum miqdorda baytlarni o'tkazib yuborishingiz va ularni o'qimasligingiz mumkin.

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

Dastur chiqishi:

reset()

Metod buferlangan oqimni oxirgi belgilanguncha pozitsiyani qaytaradi. Agar boshqa belgilanmagan bo'lsa, yozib qo'yilgan pozitsiyani 0 darajasiga oladi.

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

       System.out.println("reset() metodi chaqirildi");
       input.reset();
       System.out.println("o'qildi: " + input.read());
       System.out.println("o'qildi: " + input.read());
   } catch (IOException e) {
       e.printStackTrace();
   }
}
    

Natijada, reset() metod chaqirilgandan so'ng oqimimiz boshlanishiga qaytilishini ko'ramiz.

Dastur chiqishi:

mark(int readAheadLimit)

mark() metodi ByteArrayInputStream klass ichida ichki belgini joriy bayt pozitsiyasida o'rnatadi, ya'ni oldingi baytdan keyin. Ushbu metod parametrni qabul qiladi, ya'ni necha baytni o'qisa bo'ladi belgisidan so'ng, u yaroqsiz bo'lmasdan. Standart bo'lib, agar belgi aniq o'rnatilmagan bo'lsa, ByteArrayInputStream 0 pozitsiyani yoki konstruktorga berilgan siljishni belgilaydi. Ahamiyatli narsa shundaki, bu klassda belgilanadigan readAheadLimit yaroqsiz.

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

Mana ByteArrayInputStream da mark() metodi orqali belgini o'rnatishning misoli va reset() metodidan foydalanish. Biz oldingi misolga mark() metodi chaqiruvini qo'shamiz:

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

       System.out.println("o'qildi: " + input.read());
       System.out.println("o'qildi: " + input.read());

       System.out.println("reset() metodi chaqirildi");
       input.reset();

       System.out.println("o'qildi: " + input.read());
       System.out.println("o'qildi: " + input.read());

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

Natijada biz oqimning joriy pozitsiyasi allaqachon o'zgarganini ko'rishimiz mumkin.

Dastur chiqishi:

markSupported()

markSupported() metodi belgi qo'yish imkoniyatini tekshirish imkonini beradi. Natija qanday berilganini tushunish uchun, metodga o'tamiz:

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

Bizning metod har doim true qaytaradi. Buni misolda tekshiramiz:

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("o'qildi: " + bais.read());
       System.out.println("o'qildi: " + bais.read());

       bais.mark(1);
       System.out.println("o'qildi: " + 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();
   }
}
    

Natijada, mark() va reset() metodlari qo'llanganidan so'ng oqim har doim tayyor va belgi qo'yishga qodir:

Dastur chiqishi:

close()

close metodining ishlashini tushunish uchun, nima ichida ekanligini ko'rib chiqamiz:

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

Close metodining hujjatlarida shunday deyiladi: ByteArrayInputStream ni yopish hech qanday ta'sir ko'rsatmaydi. ByteArrayInputStream klassidagi metodlarni oqimi yopilganidan so'ng IOException davomida chaqirish mumkin.

Nima xulosaga kelishimiz mumkin?

ByteArrayInputStream bizga kerak bo'ladi, agar biz baytlar massivini o'qishimiz kerak bo'lsa. Odatda, bu klass o'zini o'zi foydalanish uchun emas, balki boshqa InputStream bilan ishlay oladigan kod bilan birga ishlatish mantiqiy bo'ladi.