Interfețe standard: InputStream, OutputStream

„Bună ziua, Amigo! Acum vă voi vorbi despre două interfețe: InputStream și OutputStream . Sunt declarate ca clase abstracte, dar dacă cercetați mai profund, puteți vedea că sunt în esență interfețe . Aproape toate metodele lor sunt abstracte, cu excepția câteva metode nesemnificative. Ele seamănă foarte mult cu „ garda de corp ” pe care am considerat-o mai devreme.

Acestea sunt interfețe foarte interesante. Deocamdată, le voi numi în mod deliberat interfețe , ca să înțelegeți de ce avem nevoie de ele. Și apoi vom vorbi despre de ce sunt de fapt clase abstracte.

"Bine. Deci care sunt aceste interfețe?"

— O să-ți spun fără alte prelungiri.

Java are acest lucru interesant numit „ flux ”. Un flux este o entitate foarte simplă. Iar simplitatea sa este cheia pentru un mod foarte puternic de a face schimb de date. Există două tipuri de fluxuri: fluxuri pentru citire și fluxuri pentru scriere .

După cum probabil ați ghicit deja, puteți scrie date într- un flux pentru scriere . Are o metodă de scriere pentru asta. Puteți citi date dintr- un flux pentru citire . Are o metodă de citire () pentru aceasta.

InputStream  este interfața pentru un flux care acceptă citirea. Acesta definește următoarea abilitate: „octeții pot fi citiți de la mine”.

În mod similar, OutputStream , un OutputStream este o interfață pentru un flux care acceptă scrierea. Ea definește următoarea abilitate: „mi pot fi scrieți octeți”.

"Asta este?"

"Destul de mult. Dar ideea este că Java are o mulțime de clase care pot funcționa cu InputStream și OutputStream . De exemplu, doriți să citiți un fișier de pe disc și să afișați conținutul acestuia pe ecran. Nimic nu ar putea fi mai ușor."

Pentru a citi date dintr-un fișier de pe disc, avem clasa specială FileInputStream , care implementează interfața InputStream . Doriți să scrieți aceste date într-un alt fișier? Pentru aceasta, avem clasa FileOutputStream , care implementează interfața OutputStream . Următorul cod arată ce trebuie să faceți pentru a copia datele dintr-un fișier în altul.

public static void main(String[] args) throws IOException
{
 InputStream inStream = new FileInputStream("c:/source.txt");
 OutputStream outStream = new FileOutputStream("c:/result.txt");

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one byte from the input stream
  outStream.write(data); //write that byte to the other stream.
 }

 inStream.close(); //close the streams
 outStream.close();
}

Imaginează-ți că am scris o clasă și i-am adăugat  abilitățile InputStream  și  OutputStream .

Dacă am implementat corect aceste interfețe, atunci instanțe ale clasei noastre pot fi acum salvate sau citite dintr-un fișier. Pur și simplu citind conținutul lor folosind metoda citire . Sau pot fi încărcate dintr-un fișier prin crearea unui obiect și folosind metoda de scriere pentru a scrie conținutul fișierului.

— Poate un exemplu?

"Sigur."

class MyClass
{
private ArrayList<Integer> list;
}

Acum îi vom adăuga metode de citire și scriere

class MyClass
{
private ArrayList<Integer> list;
public void write(int data)
{
list.add(data);
}
public int read()
{
int first = list.get(0);
list.remove(0);
return first;
}

public int available()
{
return list.size();
}
}

Desigur, aceasta nu este o implementare a interfețelor InputStream și OutputStream, dar este foarte asemănătoare.

"Da, înțeleg. Deci cum salvezi conținutul unui astfel de obiect într-un fișier?"

„Permiteți-mi să vă dau un exemplu:”

public static void main(String[] args)
{
 MyClass myObject = new MyClass();
 OutputStream outStream = new FileOutputStream ("c:/my-object-data.txt");

 while (myObject.available() > 0)
 {
  int data = myObject.read(); //read one int from the input stream
  outStream.write(data); //write that int to the other stream.
 }

 outStream.close();
}

public static void main(String[] args)
{
 InputStream inStream = new FileInputStream("c:/my-object-data.txt");
 MyClass myObject = new MyClass();

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one int from the input stream
  myObject.write(data); //write that int to the other stream.
 }

 inStream.close(); //close the streams
}

"Holy Moly! Este într-adevăr foarte asemănător cu lucrul cu InputStream/OutputStream. Fluxurile sunt drăguțe!"

— Și apoi niște!