"Inizieremo con i flussi per l'input/output dei file. Ma prima le cose."

Esistono due classi per la lettura e la scrittura di file: FileInputStream e FileOutputStream . Come probabilmente hai già intuito, FileInputStream può leggere sequenzialmente byte da un file e FileOutputStream può scrivere sequenzialmente byte su un file. Ecco i metodi che hanno queste classi:

Metodo Cosa fa il metodo 
FileInputStream(String fileName);
 — Questo è il costruttore. Consente di specificare il nome di un file su disco, dal quale l'oggetto creato leggerà i dati. 
int read();
 — Questo metodo legge un byte dal file e lo restituisce. Il valore restituito viene ampliato a un int. 
int available();
 — Questo metodo restituisce il numero di byte non letti (disponibili). 
void close();
 — Questo metodo «chiude» il flusso. Lo chiami quando hai finito di lavorare con lo stream.
L'oggetto quindi esegue le operazioni di pulizia necessarie per chiudere il file, ecc.
A questo punto, non è possibile leggere altri dati dallo stream.
Java university

Solo per il gusto di farlo, calcoliamo la somma di tutti i byte in un file. Ecco come appare il codice:

Riassumi tutti i byte in un file 
public static void main(String[] args) throws Exception
{
 //Create a FileInputStream object bound to «c:/data.txt».
 FileInputStream inputStream = new FileInputStream("c:/data.txt");
 long sum = 0;

 while (inputStream.available() > 0) //as long as there are unread bytes
 {
  int data = inputStream.read(); //Read the next byte
  sum +=  data; //Add it to the running total
 }
 inputStream.close(); // Close the stream

 System.out.println(sum); // Display the sum on the screen.
}

"Abbiamo già esaminato qualcosa del genere. Come è organizzato FileOutputStream?"

"OK. Guarda questo:"

Metodo Cosa fa il metodo 
FileOutputStream (String fileName);
 "Questo è il costruttore. Ti consente di specificare il nome di un file su disco, in cui l'oggetto creato scriverà i dati." 
void write(int data);
 "Questo metodo scrive il byte successivo, troncando i dati a un byte." 
void flush();
 "I dati da scrivere spesso vengono prima raccolti in grandi blocchi in memoria e poi scritti solo su disco."

Il comando flush forza la scrittura su disco di tutte le informazioni non salvate.

 
void close();
 "Questo metodo «chiude» il flusso. Lo chiami quando hai finito di lavorare con il flusso."
L'oggetto esegue quindi le operazioni di pulizia necessarie per chiudere il file, ecc.

Non è più possibile scrivere dati nel flusso e flush viene chiamato automaticamente.

"Questo è tutto?"

"Sì, in realtà c'è solo un metodo per scrivere: write (). Scrive solo un byte alla volta. Ma ti consente di scrivere tutte le informazioni che vuoi nel file."

La programmazione è un processo di divisione di un compito grande e complesso in molti piccoli. Essenzialmente lo stesso processo sta accadendo qui: la lettura e la scrittura di grandi blocchi di dati viene suddivisa in lettura e scrittura in piccoli pezzi, un byte alla volta.

Ecco come puoi utilizzare queste classi per copiare un file su disco:

Copia un file su disco 
public static void main(String[] args) throws Exception
{
 //Create a stream to read bytes from a file
 FileInputStream inputStream = new FileInputStream("c:/data.txt");
 //Create a stream to write bytes to a file
 FileOutputStream outputStream = new FileOutputStream("c:/result.txt");

 while (inputStream.available() > 0) //as long as there are unread bytes
 {
  int data = inputStream.read(); // Read the next byte into the data variable
  outputStream.write(data); // and write it to the second stream
 }

 inputStream.close(); //Close both streams. We don't need them any more.
 outputStream.close();
}

"Grazie, Rishi. Finalmente ho capito come funziona questo codice."