Standaardinterfaces: InputStream, OutputStream

"Hallo, Amigo! Nu zal ik je vertellen over twee interfaces: InputStream en OutputStream . Ze worden gedeclareerd als abstracte klassen, maar als je dieper graaft, kun je zien dat het in wezen interfaces zijn . Bijna al hun methoden zijn abstract, behalve een paar onbetekenende methoden. Ze lijken erg op de ' lijfwacht ' die we eerder hebben overwogen.'

Dit zijn zeer interessante interfaces. Voor nu ga ik ze opzettelijk interfaces noemen , zodat je begrijpt waarom we ze nodig hebben. En dan zullen we het hebben over waarom het eigenlijk abstracte klassen zijn.

"Oké. Dus wat zijn deze interfaces?"

"Ik zal het je zonder verder oponthoud vertellen."

Java heeft iets interessants dat een " stream " wordt genoemd. Een stream is een heel eenvoudige entiteit. En de eenvoud ervan is de sleutel tot een zeer krachtige manier om gegevens uit te wisselen. Er zijn twee soorten streams: streams voor lezen en streams voor schrijven .

Zoals je waarschijnlijk al geraden hebt, kun je gegevens naar een stream schrijven om te schrijven . Hiervoor heeft het een schrijfmethode . U kunt gegevens uit een stream lezen om te lezen . Hiervoor heeft het een read () methode.

InputStream  is de interface voor een stream die lezen ondersteunt. Het definieert de volgende mogelijkheid: «bytes kunnen van mij worden gelezen».

Evenzo is OutputStream , een OutputStream een ​​interface voor een stream die schrijven ondersteunt. Het definieert de volgende mogelijkheid: «bytes kunnen naar mij worden geschreven».

"Dat is het?"

"Vrijwel. Maar het gaat erom dat Java heel veel klassen heeft die kunnen werken met InputStream en OutputStream . Je wilt bijvoorbeeld een bestand van schijf lezen en de inhoud ervan op het scherm weergeven. Niets is eenvoudiger."

Om gegevens uit een bestand op schijf te lezen, hebben we de speciale FileInputStream- klasse, die de InputStream- interface implementeert. Wilt u deze gegevens wegschrijven naar een ander bestand? Hiervoor hebben we de FileOutputStream- klasse, die de OutputStream- interface implementeert. De volgende code laat zien wat u moet doen om gegevens van het ene bestand naar het andere te kopiëren.

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

Stel je voor dat we een klasse hebben geschreven en de  mogelijkheden InputStream  en  OutputStream eraan hebben toegevoegd.

Als we deze interfaces correct hebben geïmplementeerd, kunnen instanties van onze klasse nu worden opgeslagen in of gelezen uit een bestand. Gewoon door hun inhoud te lezen met behulp van de leesmethode . Of ze kunnen uit een bestand worden geladen door een object te maken en de schrijfmethode te gebruiken om de inhoud van het bestand te schrijven .

"Misschien een voorbeeld?"

"Zeker."

class MyClass
{
private ArrayList<Integer> list;
}

Nu gaan we er lees- en schrijfmethoden aan toevoegen

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

Dit is natuurlijk geen implementatie van de InputStream- en OutputStream-interfaces, maar het lijkt er erg op.

"Ja, dat begrijp ik. Dus hoe sla je de inhoud van zo'n object op in een bestand?"

"Laat me je een voorbeeld geven:"

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! Het lijkt echt erg op werken met InputStream/OutputStream. Streams zijn lief!"

"En dan een beetje!"