Standard grensesnitt: InputStream, OutputStream

"Hei, Amigo! Nå skal jeg fortelle deg om to grensesnitt: InputStream og OutputStream . De er deklarert som abstrakte klasser, men hvis du graver dypere kan du se at de i hovedsak er grensesnitt . Nesten alle metodene deres er abstrakte, bortsett fra noen få ubetydelige metoder. De ligner veldig på " livvakten " vi vurderte tidligere.

Dette er veldig interessante grensesnitt. Foreløpig skal jeg bevisst kalle dem grensesnitt , så du forstår hvorfor vi trenger dem. Og så skal vi snakke om hvorfor de faktisk er abstrakte klasser.

"Ok. Så hva er disse grensesnittene?"

"Jeg skal fortelle deg det uten videre."

Java har denne interessante tingen som kalles en « strøm ». En strøm er en veldig enkel enhet. Og dens enkelhet er nøkkelen til en veldig kraftig måte å utveksle data på. Det er to typer strømmer: strømmer for lesing og strømmer for skriving .

Som du sikkert allerede har gjettet, kan du skrive data til en strøm for å skrive . Den har en skrivemetode for dette. Du kan lese data fra en strøm for lesing . Den har en lese ()-metode for dette.

InputStream  er grensesnittet for en strøm som støtter lesing. Den definerer følgende evne: «bytes kan leses fra meg».

Tilsvarende er OutputStream , en OutputStream et grensesnitt for en strøm som støtter skriving. Den definerer følgende evne: «bytes kan skrives til meg».

"Det er det?"

"Ganske mye. Men hele poenget er at Java har massevis av klasser som kan fungere med InputStream og OutputStream . For eksempel vil du lese en fil fra disk og vise innholdet på skjermen. Ingenting kan være enklere."

For å lese data fra en fil på disk har vi den spesielle FileInputStream- klassen, som implementerer InputStream- grensesnittet. Vil du skrive disse dataene til en annen fil? For dette har vi FileOutputStream- klassen, som implementerer OutputStream- grensesnittet. Følgende kode viser hva du må gjøre for å kopiere data fra en fil til en annen.

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

Tenk deg at vi har skrevet en klasse og lagt til  InputStream-  og  OutputStream -evnene til den.

Hvis vi implementerte disse grensesnittene riktig, kan forekomster av klassen vår nå lagres til eller leses fra en fil. Bare ved å lese innholdet ved hjelp av lesemetoden . Eller de kan lastes fra en fil ved å lage et objekt og bruke skrivemetoden til å skrive filinnholdet.

"Kanskje et eksempel?"

"Sikker."

class MyClass
{
private ArrayList<Integer> list;
}

Nå skal vi legge til lese- og skrivemetoder til den

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

Dette er selvfølgelig ikke en implementering av InputStream- og OutputStream-grensesnittene, men det er veldig likt.

"Ja, jeg forstår. Så hvordan lagrer du innholdet i et slikt objekt i en fil?"

"La meg gi deg et eksempel:"

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! Det er veldig likt å jobbe med InputStream/OutputStream. Strømmer er søte!"

"Og litt til!"