« Nous allons commencer par les flux pour l'entrée/la sortie de fichiers. Mais prenons les choses par le bon bout. »

Il y a deux classes pour lire et écrire des fichiers : FileInputStream et FileOutputStream. Comme tu l'auras probablement déjà deviné, FileInputStream peut lire de manière séquentielle les octets d'un fichier, et FileOutputStream écrire de manière séquentielle des octets dans un fichier. Voici les méthodes que ces classes possèdent :

Méthode Ce que la méthode fait 
FileInputStream(String fileName);
 - Il s'agit du constructeur. Il te permet de spécifier le nom d'un fichier sur le disque, à partir duquel l'objet créé lira les données. 
int read();
 - Cette méthode lit un octet depuis le fichier et le renvoie. La valeur de retour est élargie en int. 
int available();
 - Cette méthode renvoie le nombre d'octets non lus (disponibles). 
void close();
 - Cette méthode « ferme » le flux. Tu peux l'appeler quand tu as fini de travailler avec le flux.
L'objet effectue alors les opérations d'entretien nécessaires pour fermer le fichier, etc.
À ce stade, tu ne peux plus lire de données à partir du flux.

Juste pour le plaisir, nous allons calculer la somme de tous les octets dans un fichier. Voici à quoi le code ressemble :

Somme de tous les octets dans un fichier
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.
}

« Nous avons déjà étudié quelque chose de semblable. Comment est-ce que la classe FileOutputStream est organisée ? »

« Très bien. Regarde ça : »

Méthode Ce que la méthode fait 
FileOutputStream (String fileName);
 « Il s'agit du constructeur. Il te permet de spécifier le nom d'un fichier sur le disque, dans lequel l'objet écrira les données. » 
void write(int data);
 « Cette méthode écrit l'octet suivant, en tronquant les données à un octet. » 
void flush();
 « Les données à écrire sont souvent d'abord recueillies dans de grands blocs en mémoire, et seulement alors écrites sur le disque. »

La commande flush force l'écriture de toutes les informations non enregistrées sur le disque.

 
void close();
 « Cette méthode 'ferme' le flux. Tu peux l'appeler quand tu as fini de travailler avec le flux. »
L'objet effectue alors les opérations d'entretien nécessaires pour fermer le fichier, etc.

Tu ne peux plus écrire des données sur le flux, et la méthode flush est appelée automatiquement.

« C'est tout ? »

« Oui, il n'existe en fait qu'une seule méthode pour l'écriture : write(). Et elle écrit un seul octet à la fois. Mais elle te permet d'écrire autant d'informations que tu veux dans le fichier. »

La programmation est le processus de division d'une tâche vaste et complexe en de nombreux petits éléments. C'est essentiellement le même processus qui se déroule ici : la lecture/écriture de gros blocs de données est divisée en lecture/écriture de petits morceaux d'un octet à la fois.

Voici comment tu peux utiliser ces classes pour copier un fichier sur le disque :

Copier un fichier sur le disque
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();
}

« Merci, Rishi. Je comprends enfin comment ce code fonctionne réellement. »

Java webinar