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!

3

Sarcină

Java Core, nivel, lecţie

Blocat

Code entry

Sometimes you don't need to think, you just need to hammer it out! As paradoxical as it may seem, sometimes your fingers will "remember" better than your conscious mind. That's why while training at the secret CodeGym center you will sometimes encounter tasks that require you to enter code. By entering code, you get used to the syntax and assimilate some material. What's more, you combat laziness.

Deschis