Fluxuri bufere BufferedInputStream și BufferedOutputStream

Pentru optimizarea operațiilor de intrare-ieșire se folosesc fluxuri bufere. Aceste fluxuri adaugă un buffer special în memorie la fluxurile standard, ceea ce crește performanța la citirea și scrierea fluxurilor.

Clasa BufferedInputStream

Clasa BufferedInputStream acumulează datele de intrare într-un buffer special, fără a accesa constant dispozitivul de intrare. Aceasta definește doi constructori:

BufferedInputStream(InputStream inputStream)  
BufferedInputStream(InputStream inputStream, int bufSize)

Primul parametru reprezintă fluxul de intrare din care se citesc datele în buffer, iar al doilea parametru specifică dimensiunea bufferului.

De exemplu, să buferizăm citirea datelor din fluxul ByteArrayInputStream:

import java.io.*;

public class Program {

   public static void main(String[] args) {

       String text = "Hello world!";
       byte[] buffer = text.getBytes();
       ByteArrayInputStream in = new ByteArrayInputStream(buffer);

       try (BufferedInputStream bis = new BufferedInputStream(in)) {

           int c;
           while ((c = bis.read()) != -1) {

               System.out.print((char) c);
           }
       } catch (Exception e) {

           System.out.println(e.getMessage());
       }
       System.out.println();
   }
}

Clasa BufferedInputStream primește în constructor un obiect InputStream. În acest caz, obiectul este o instanță a clasei ByteArrayInputStream.

Ca toate fluxurile de intrare, BufferedInputStream are metoda read(), care citește datele. Aici citim fiecare octet din tabloul buffer folosind metoda read.

Practic, același lucru s-ar fi putut realiza și folosind doar ByteArrayInputStream, fără a apela la fluxul buffer. Clasa BufferedInputStream doar optimizează performanța în timpul lucrului cu fluxul ByteArrayInputStream. Desigur, în loc de ByteArrayInputStream, poate fi utilizată orice altă clasă care moștenește InputStream.

Clasa BufferedOutputStream

Clasa BufferedOutputStream creează în mod similar un buffer pentru fluxurile de ieșire. Acest buffer acumulează octeții de ieșire, fără a accesa constant dispozitivul de ieșire. Când bufferul este plin, datele sunt scrise.

BufferedOutputStream definește doi constructori:

BufferedOutputStream(OutputStream outputStream)  
BufferedOutputStream(OutputStream outputStream, int bufSize)

Primul parametru este fluxul de ieșire moștenit din OutputStream, iar al doilea parametru este dimensiunea bufferului.

Să analizăm un exemplu de scriere într-un fișier:

import java.io.*;

public class Program {

   public static void main(String[] args) {

       String text = "Hello world!"; // șir pentru scriere
       try (FileOutputStream out = new FileOutputStream("notes.txt");
               BufferedOutputStream bos = new BufferedOutputStream(out)) {
           
           // convertirea șirului în octeți
           byte[] buffer = text.getBytes();
           bos.write(buffer, 0, buffer.length);
       } catch (IOException ex) {

           System.out.println(ex.getMessage());
       }
   }
}

Clasa BufferedOutputStream primește ca parametru în constructor un obiect OutputStream - în acest caz, este fluxul de ieșire FileOutputStream. Se realizează apoi scrierea în fișier. Similar cu BufferedInputStream, BufferedOutputStream nu adaugă multe funcționalități noi, ci doar optimizează operațiunile de ieșire.