Standardgränssnitt: InputStream, OutputStream

"Hej, Amigo! Nu ska jag berätta om två gränssnitt: InputStream och OutputStream . De deklareras som abstrakta klasser, men om du gräver djupare kan du se att de i huvudsak är gränssnitt . Nästan alla deras metoder är abstrakta, förutom för några obetydliga metoder, de påminner mycket om " livvakten " som vi övervägde tidigare.

Det här är väldigt intressanta gränssnitt. För tillfället kommer jag medvetet att kalla dem för gränssnitt , så att du förstår varför vi behöver dem. Och sedan ska vi prata om varför de faktiskt är abstrakta klasser.

"Okej. Så vad är dessa gränssnitt?"

"Jag ska berätta för dig utan vidare."

Java har denna intressanta sak som kallas en " ström ". En ström är en mycket enkel enhet. Och dess enkelhet är nyckeln till ett mycket kraftfullt sätt att utbyta data. Det finns två typer av strömmar: strömmar för läsning och strömmar för skrivning .

Som du säkert redan gissat kan du skriva data till en ström för att skriva . Den har en skrivmetod för detta. Du kan läsa data från en ström för läsning . Den har en läsmetod () för detta.

InputStream  är gränssnittet för en stream som stöder läsning. Den definierar följande förmåga: «byte kan läsas från mig».

På liknande sätt är OutputStream , en OutputStream ett gränssnitt för en ström som stöder skrivning. Den definierar följande förmåga: «byte kan skrivas till mig».

"Det är allt?"

"Ganska mycket. Men hela poängen är att Java har massor av klasser som kan fungera med InputStream och OutputStream . Du vill till exempel läsa en fil från disk och visa dess innehåll på skärmen. Ingenting kan vara enklare."

För att läsa data från en fil på disk har vi den speciella FileInputStream- klassen, som implementerar InputStream -gränssnittet. Vill du skriva dessa data till en annan fil? För detta har vi klassen FileOutputStream , som implementerar OutputStream -gränssnittet. Följande kod visar vad du behöver göra för att kopiera data från en fil till en annan.

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

Föreställ dig att vi har skrivit en klass och lagt till  förmågorna InputStream  och  OutputStream till den.

Om vi ​​implementerade dessa gränssnitt på rätt sätt kan instanser av vår klass nu sparas till eller läsas från en fil. Helt enkelt genom att läsa deras innehåll med hjälp av läsmetoden . Eller så kan de laddas från en fil genom att skapa ett objekt och använda skrivmetoden för att skriva filens innehåll.

"Kanske ett exempel?"

"Säker."

class MyClass
{
private ArrayList<Integer> list;
}

Nu ska vi lägga till läs- och skrivmetoder till 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();
}
}

Naturligtvis är detta inte en implementering av gränssnitten InputStream och OutputStream, men det är väldigt likt.

"Ja, jag förstår. Så hur sparar man innehållet i ett sådant objekt i en fil?"

"Låt mig ge dig ett exempel:"

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 är verkligen mycket likt att arbeta med InputStream/OutputStream. Strömmar är söta!"

"Och sen lite!"