Standardgrænseflader: InputStream, OutputStream

"Hej, Amigo! Nu vil jeg fortælle dig om to grænseflader: InputStream og OutputStream . De er erklæret som abstrakte klasser, men hvis du graver dybere, kan du se, at de i det væsentlige er grænseflader . Næsten alle deres metoder er abstrakte, undtagen for nogle få ubetydelige metoder, de minder meget om den " livvagt ", vi overvejede tidligere.

Disse er meget interessante grænseflader. For nu vil jeg bevidst kalde dem grænseflader , så du forstår, hvorfor vi har brug for dem. Og så vil vi tale om, hvorfor de faktisk er abstrakte klasser.

"Okay. Så hvad er disse grænseflader?"

"Jeg fortæller dig det uden videre."

Java har denne interessante ting kaldet en " strøm ". En strøm er en meget simpel enhed. Og dens enkelhed er nøglen til en meget effektiv måde at udveksle data på. Der er to typer streams: streams til læsning og streams til skrivning .

Som du sikkert allerede har gættet, kan du skrive data til en strøm til skrivning . Den har en skrivemetode til dette. Du kan læse data fra en strøm til læsning . Det har en læse () metode til dette.

InputStream  er grænsefladen til en stream, der understøtter læsning. Den definerer følgende evne: «bytes kan læses fra mig».

På samme måde er OutputStream , en OutputStream en grænseflade til en stream, der understøtter skrivning. Den definerer følgende evne: «bytes kan skrives til mig».

"Det er det?"

"Temmelig meget. Men hele pointen er, at Java har masser af klasser, der kan arbejde med InputStream og OutputStream . For eksempel vil du læse en fil fra disken og vise dens indhold på skærmen. Intet kunne være nemmere."

For at læse data fra en fil på disk har vi den specielle FileInputStream- klasse, som implementerer InputStream- grænsefladen. Vil du skrive disse data til en anden fil? Til dette har vi FileOutputStream- klassen, som implementerer OutputStream- grænsefladen. Følgende kode viser, hvad du skal gøre for at kopiere data fra en fil til en anden.

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

Forestil dig, at vi har skrevet en klasse og tilføjet  InputStream-  og  OutputStream- evnerne til den.

Hvis vi implementerede disse grænseflader korrekt, kan forekomster af vores klasse nu gemmes til eller læses fra en fil. Simpelthen ved at læse deres indhold ved hjælp af læsemetoden . Eller de kan indlæses fra en fil ved at oprette et objekt og bruge skrivemetoden til at skrive filens indhold.

"Måske et eksempel?"

"Jo da."

class MyClass
{
private ArrayList<Integer> list;
}

Nu vil vi tilføje læse- og skrivemetoder til det

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 af InputStream- og OutputStream-grænsefladerne, men det er meget ens.

"Ja, jeg forstår det. Så hvordan gemmer man indholdet af sådan et objekt i en fil?"

"Lad mig give dig 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 minder virkelig meget om at arbejde med InputStream/OutputStream. Streams er søde!"

"Og så nogle!"