Interfacce standard: InputStream, OutputStream

Queste sono interfacce molto interessanti. Per ora, le chiamerò deliberatamente interfacce , in modo da capire perché ne abbiamo bisogno. E poi parleremo del perché in realtà sono classi astratte.

"Okay. Allora, quali sono queste interfacce?"

"Te lo dirò senza ulteriori indugi."

Java ha questa cosa interessante chiamata « stream ». Un flusso è un'entità molto semplice. E la sua semplicità è la chiave per un modo molto potente di scambiare dati. Esistono due tipi di flussi: flussi per la lettura e flussi per la scrittura .

Come probabilmente hai già intuito, puoi scrivere dati in un flusso per la scrittura di file . Ha un metodo di scrittura per questo. È possibile leggere i dati da un flusso per la lettura . Ha un metodo read () per questo.

InputStream  è l'interfaccia per un flusso che supporta la lettura. Definisce la seguente abilità: «i byte possono essere letti da me».

Allo stesso modo, OutputStream , un OutputStream è un'interfaccia per un flusso che supporta la scrittura. Definisce la seguente abilità: «mi si possono scrivere byte».

"Questo è tutto?"

"Più o meno. Ma il punto è che Java ha un sacco di classi che possono funzionare con InputStream e OutputStream . Ad esempio, vuoi leggere un file dal disco e visualizzarne il contenuto sullo schermo. Niente potrebbe essere più semplice."

Per leggere i dati da un file su disco, abbiamo la speciale classe FileInputStream , che implementa l' interfaccia InputStream . Vuoi scrivere questi dati in un altro file? Per questo, abbiamo la classe FileOutputStream , che implementa l' interfaccia OutputStream . Il codice seguente mostra cosa è necessario fare per copiare i dati da un file a un altro.

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

Immagina di aver scritto una classe e di avervi aggiunto le  abilità InputStream  e  OutputStream .

Se abbiamo implementato correttamente queste interfacce, le istanze della nostra classe ora possono essere salvate o lette da un file. Semplicemente leggendo il loro contenuto usando il metodo read . Oppure possono essere caricati da un file creando un oggetto e utilizzando il metodo write per scrivere il contenuto del file.

"Forse un esempio?"

"Sicuro."

class MyClass
{
private ArrayList<Integer> list;
}

Ora aggiungeremo i metodi di lettura e scrittura ad esso

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

Naturalmente, questa non è un'implementazione delle interfacce InputStream e OutputStream, ma è molto simile.

"Sì, ho capito. Quindi come si salva il contenuto di un oggetto del genere in un file?"

"Lasciate che vi faccia un esempio:"

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
}

"Santo cielo! È davvero molto simile a lavorare con InputStream/OutputStream. I flussi sono dolci!"

"E poi qualche!"