19. Les flux

Un programme a souvent besoin d'échanger des informations pour recevoir des données d'une source ou pour envoyer des données vers un destinataire.

La source et la destination de ces échanges peuvent être de nature multiple : un fichier, une socket réseau, un autre programme, etc ...

De la même façon, la nature des données échangées peut être diverse : du texte, des images, du son, etc ...

Ce chapitre contient plusieurs sections :

• Présentation des flux
• Les classes de gestion des flux
• Les flux de caractères
• Les flux d'octets
• La classe File
• Les fichiers à accès direct

19.1. Présentation des flux

Les flux (stream en anglais) permettent  d'encapsuler ces processus d'envoi et de réception de données. Les flux traitent toujours les données de façon séquentielle.

En java, les flux peuvent être divisés en plusieurs catégories :

• les flux d'entrée (input stream) et les flux de sortie (output stream)
• les flux de traitement de caractères et les flux de traitement d'octets

Java définit des flux pour lire ou écrire des données mais aussi des classes qui permettent de faire des traitements sur les données du flux. Ces classes doivent être associées à un flux de lecture ou d'écriture et sont considérées comme des filtres. Par exemple, il existe des filtres qui permettent de mettre les données traitées dans un tampon (buffer) pour les traiter par lots.

Toutes ces classes sont regroupées dans le package java.io.

19.2. Les classes de gestion des flux

Ce qui déroute dans l'utilisation de ces classes, c'est leur nombre et la difficulté de choisir celle qui convient le mieux en fonction des besoins. Pour faciliter ce choix, il faut comprendre la dénomination des classes : cela permet de sélectionner la ou les classes adaptées aux traitements à réaliser.

Le nom des classes se décompose en un préfixe et un suffixe. Il y a quatre suffixes possibles en fonction du type de flux (flux d'octets ou de caractères) et du sens du flux (entrée ou sortie).

Il exite donc quatre hiérarchies de classes qui encapsulent des types de flux particuliers. Ces classes peuvent être séparées en deux séries de deux catégories différentes : les classes de lecture et d'écriture et les classes permettant la lecture de caractères ou d'octets.

• les sous classes de Reader sont des types de flux en lecture sur des ensembles de caractères
• les sous classes de Writer sont des types de flux en écriture sur des ensembles de caractères
• les sous classes de InputStream sont des types de flux en lecture sur des ensembles d'octets
• les sous classes de OutputStream sont des types de flux en écriture sur des ensembles d'octets

Pour le préfixe, il faut distinguer les flux et les filtres. Pour les flux, le préfixe contient la source ou la destination selon le sens du flux.

Pour les filtres, le préfixe contient le type de traitement qu'il effectue. Les filtres n'existent pas obligatoirement pour des flux en entrée et en sortie.

• Buffered : ce type de filtre permet de mettre les données du flux dans un tampon. Il peut être utilisé en entrée et en sortie
• Sequence : ce filtre permet de fusionner plusieurs flux.
• Data : ce type de flux permet de traiter les octets sous forme de type de données
• LineNumber : ce filtre permet de numéroter les lignes contenues dans le flux
• PushBack : ce filtre permet de remettre des données lues dans le flux
• Print : ce filtre permet de réaliser des impressions formatées
• Object : ce filtre est utilisé par la sérialisation
• InputStream / OuputStream : ce filtre permet de convertir des octets en caractères

La package java.io définit ainsi plusieurs classes :

19.3. Les flux de caractères

Ils transportent des données sous forme de caractères : java les gèrent avec le format Unicode qui code les caractères sur 2 octets.

Ce type de flux a été ajouté à partir du JDK 1.1.

Les classes qui gèrent les flux de caractères héritent d'une des deux classes abstraites Reader ou Writer. Il existe de nombreuses sous classes pour traiter les flux de caractères.

19.3.1. La classe Reader

C'est une classe abstaite qui est la classe mère de toutes les classes qui gèrent des flux de caractères en lecture.

Cette classe définit plusieurs méthodes :

19.3.2. La classe Writer

C'est une classe abstaite qui est la classe mère de toutes les classes qui gèrent des flux de caractères en écriture.

Cette classe définit plusieurs méthodes :

19.3.3. Les flux de caractères avec un fichier

Les classes FileReader et FileWriter permettent de gérer des flux de caractères avec des fichiers.

19.3.3.1. Les flux de caractères en lecture sur un fichier

Il faut instancier un objet de la classe FileReader. Cette classe hérite de la classe InputStreamReader et possède plusieurs constructeurs qui peuvent tous lever une exception de type FileNotFoundException:

FileReader fichier = new FileReader(«monfichier.txt»);

Il existe plusieurs méthodes de la classe FileReader qui permettent de lire un ou plusieurs caractères dans le flux. Toutes ces méthodes sont héritées de la classe Reader et peuvent toutes lever l'exception IOException.

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

19.3.3.2. Les flux de caractères en écriture sur un fichier

Il faut instancier un objet de la classe FileWriter qui hérite de la classe OuputStreamWriter. Cette classe possède plusieurs constructeurs :

FileWriter fichier = new FileWriter («monfichier.dat»);

Il existe plusieurs méthodes de la classe FileWriter héritées de la classe Writer qui permettent d'écrire un ou plusieurs caractères dans le flux.

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

19.3.4. Les flux de caractères tamponnés avec un fichier.

Pour améliorer les performances des flux sur un fichier, la mise en tampon des données lues ou écrites  permet de traiter un ensemble de caractères représentant une ligne  plutôt que de traiter les données caractères par caractères. Le nombre d'opérations est ainsi réduit.

Les classes BufferedReader et BufferedWriter permettent de gérer des flux de caractères tamponnés avec des fichiers.

19.3.4.1. Les flux de caractères tamponnés en lecture avec un fichier

Il faut instancier un objet de la classe BufferedReader. Cette classe possède plusieurs constructeurs qui peuvent tous lever une exception de type FileNotFoundException:

BufferedReader fichier  = new BufferedReader(new FileReader("monfichier.txt"));

Il existe plusieurs méthodes de la classe BufferedReader héritées de la classe Reader qui permettent de lire un ou plusieurs caractères dans le flux. Toutes ces méthodes peuvent lever une exception de type IOException. Elle définit une méthode supplémentaire pour la lecture :

La classe BufferedReader possède plusieurs méthodes pour gérer le flux hérité de la classe Reader.

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

import java.io.*;

public class TestBufferedReader {
  protected String source;
  
  public TestBufferedReader(String source) {
    this.source = source;
    lecture();
  }

  public static void main(String args[]) {
    new TestBufferedReader("source.txt");
  }

  private void lecture() { 
    try {
      String ligne ;
      BufferedReader fichier = new BufferedReader(new FileReader(source));
      
      while ((ligne = fichier.readLine()) != null) {
          System.out.println(ligne);
      }

      fichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }     
  }    
}

19.3.4.2. Les flux de caractères tamponnés en écriture avec un fichier

Il faut instancier un objet de la classe BufferedWriter. Cette classe possède plusieurs constructeurs :

BufferedWriter fichier = new BufferedWriter( new FileWriter(«monfichier.txt»));

Il existe plusieurs méthodes de la classe BufferedWriter héritées de la classe Writer qui permettent de lire un ou plusieurs caractères dans le flux.

La classe BufferedWriter possède plusieurs méthodes pour gérer le flux :

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

import java.io.*;
import java.util.*;

public class TestBufferedWriter {
  protected String destination;
  
  public TestBufferedWriter(String destination) {
    this.destination = destination;
    traitement();
  }

  public static void main(String args[]) {
    new TestBufferedWriter("print.txt");
  }

  private void traitement() { 
    try {
      String ligne ;
      int nombre = 123;
      BufferedWriter fichier = new BufferedWriter(new FileWriter(destination));

      fichier.write("bonjour tout le monde");
      fichier.newLine();
      fichier.write("Nous sommes le "+ new Date());      
      fichier.write(", le nombre magique est " + nombre);

      fichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }     
  }    
}

19.3.4.3. La classe PrintWriter

Cette classe permet d'écrire dans un flux des données formatées.

Cette classe possède plusieurs constructeurs :

PrintWriter fichier = new PrintWriter( new FileWriter(«monfichier.txt»));

Il existe de nombreuses méthodes de la classe PrintWriter qui permettent d'écrire un ou plusieurs caractères dans le flux en les formatant. Les méthodes write() sont héritées de la classe Writer. Elle définit plusieurs méthodes pour envoyer des données formatées dans le flux :

• print( ... )
  
  Plusieurs méthodes print acceptent des données de différents types pour les convertir en caractères et les écrire dans le flux


• println()
  
  Cette méthode permet de terminer la ligne courante dans le flux en y écrivant un saut de ligne.


• println ( ... )
  
  Plusieurs méthodes println acceptent des données de différents types pour les convertir en caractères et les écrire dans le flux avec une fin de ligne.

La classe PrintWriter possède plusieurs méthodes pour gérer le flux :

import java.io.*;
import java.util.*;

public class TestPrintWriter {
  protected String destination;
  
  public TestPrintWriter(String destination) {
    this.destination = destination;
    traitement();
  }

  public static void main(String args[]) {
    new TestPrintWriter("print.txt");
  }

  private void traitement() { 
    try {
      String ligne ;
      int nombre = 123;
      PrintWriter fichier = new PrintWriter(new FileWriter(destination));

      fichier.println("bonjour tout le monde");
      fichier.println("Nous sommes le "+ new Date());      
      fichier.println("le nombre magique est " + nombre);

      fichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }     
  }    
}

19.4. Les flux d'octets

Ils transportent des données sous forme d'octets. Les flux de ce type sont capables de traiter toutes les données.

Les classes qui gèrent les flux d'octets héritent d'une des deux classes abstraites InputStream ou OutputStream. Il existe de nombreuses sous classes pour traiter les flux d'octets.

19.4.1. Les flux d'octets avec un fichier.

Les classes FileInputStream et FileOutputStream permettent de gérer des flux d'octets avec des fichiers.

19.4.1.1. Les flux d'octets en lecture sur un fichier

Il faut instancier un objet de la classe FileInputStream. Cette classe possède plusieurs constructeurs qui peuvent tous lever l'exception FileNotFoundException:

FileInputStream fichier = new FileInputStream(«monfichier.dat»);

Il existe plusieurs méthodes de la classe FileInputStream qui permettent de lire un ou plusieurs octets dans le flux. Toutes ces méthodes peuvent lever l'exception IOException.

• int read()
  

  Cette méthode envoie la valeur de l'octet lu ou -1 si la fin du flux est atteinte.

  Exemple ( code Java 1.1 ) :

  int octet = 0; while (octet != 1 ) {    octet = fichier.read(); }

  
  
• int read(byte[], int, int)
  

  Cette méthode lit plusieurs octets. Elle attend en paramètre : un tableau d'octets qui contiendra les octets lus, l'indice du premier élément du tableau qui recevra le premier octet et le nombre d'octets à lire.

  Elle renvoie le nombre d'octets lus ou -1 si aucun octet n'a été lus. La tableau d'octets contient les octets lus.

La classe FileInputStream possède plusieurs méthodes pour gérer le flux :

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

19.4.1.2. Les flux d'octets en écriture sur un fichier

Il faut instancier un objet de la classe FileOutputStream. Cette classe possède plusieurs constructeurs :

FileOuputStream fichier = new FileOutputStream(«monfichier.dat»);

Il existe plusieurs méthodes de la classe FileOutputStream qui permettent de lire un ou plusieurs octets dans le flux.

• write(int)
  

  Cette méthode écrit l'octet en paramètre dans le flux.

• write(byte[])
  

  Cette méthode écrit plusieurs octets. Elle attend en paramètre : un tableau d'octets qui contient les octets à écrire : tous les éléments du tableau sont écrits.

• write(byte[], int, int)
  

  Cette méthode écrit plusieurs octets. Elle attend en paramètre : un tableau d'octets qui contient les octets à écrire, l'indice du premier éléments du tableau d'octets à écrire  et le nombre d'octets à écrire.

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

import java.io.*;

public class CopieFichier {
  protected String source;
  protected String destination;

  public CopieFichier(String source, String destination) {
    this.source = source;
    this.destination = destination;
    copie();
  }

  public static void main(String args[]) {
    new CopieFichier("source.txt","copie.txt");
  }

  private void copie() { 
    try {
      FileInputStream fis = new FileInputStream(source);
      FileOutputStream fos = new FileOutputStream(destination);
      while(fis.available() > 0) fos.write(fis.read());
      fis.close();
      fos.close();
    } catch (Exception e) {
      e.printStackTrace();
    }     
  }    
}

19.4.2. Les flux d'octets tamponnés avec un fichier.

Pour améliorer les performances des flux sur un fichier, la mise en tampon des données lues ou écrites  permet de traiter un ensemble d'octets plutôt que de traiter les données octets par octets. Le nombre d'opérations est ainsi réduit.

19.5. La classe File

Les fichiers et les répertoires sont encapsulés dans la classe File du package java.io. Il n'existe pas de classe pour traiter les répertoires car ils sont considérés comme des fichiers. Une instance de la classe File est une représentation logique d'un fichier ou d'un répertoire qui peut ne pas exister physiquement sur le disque.

Si le fichier ou le répertoire existe, de nombreuses méthodes de la classe File permettent d'obtenir des informations sur le fichier. Sinon plusieurs méthodes permettent de créer des fichiers ou des répertoires. Voici une liste des principales méthodes :

Méthode	Rôle
boolean canRead()	indique si le fichier peut être lu
boolean canWrite()	indique si le fichier peut être modifié
boolean createNewFile()	création d'un nouveau fichier vide
File createTempFile(String, String)	création d'un nouveau fichier dans le répertoire par défaut des fichiers temporaires. Les deux arguments sont le préfixe et le suffixe du fichier.
File createTempFile(String, String, File)	création d'un nouveau fichier temporaire. Les trois arguments sont le préfixe et le suffixe du fichier et le répertoire.
boolean delete()	détruire le fichier ou le repertoire. Le booléen indique le succés de l'opération
deleteOnExit()	demande la suppression du fichier à l'arrêt de la JVM
boolean exists()	indique si le fichier existe physiquement
String getAbsolutePath()	renvoie le chemin absolu du fichier
String getPath	renvoie le chemin du fichier
boolean isAbsolute()	indique si le chemin est absolu
boolean isDirectory()	indique si le fichier est un répertoire
boolean isFile()	indique si l'objet  représente un fichier
long length()	renvoie la longueur du fichier
String[] list()	renvoie la liste des fichiers et répertoire contenu dans le répertoire
boolean  mkdir()	création du répertoire
boolean mkdirs()	création du répertoire avec création des répertoires manquants dans l'arborescence du chemin
boolean renameTo()	renommer le fichier

Depuis la version 1.2 du J.D.K., de nombreuses fonctionnalités ont été ajoutées à cette classe :

• la création de fichiers temporaires (createNewFile, createTempFile, deleteOnExit)
  
• la gestion des attributs "caché" et "lecture seule" (isHidden, isReadOnly)
  
• des méthodes qui renvoient des objets de type File au lieu de type String ( getParentFile, getAbsoluteFile, getCanonicalFile, listFiles)
  
• une méthode qui renvoie le fichier sous forme d'URL (toURL)
  

import java.io.*;

public class TestFile {
  protected String nomFichier;
  protected File fichier;
  
  public TestFile(String nomFichier) {
    this.nomFichier = nomFichier;
    fichier = new File(nomFichier);
    traitement();
  }

  public static void main(String args[]) {
    new TestFile(args[0]);
  }

  private void traitement() {

    if (!fichier.exists()) { 
      System.out.println("le fichier "+nomFichier+"n'existe pas");
      System.exit(1);
    }      
     
    System.out.println(" Nom du fichier    : "+fichier.getName());
    System.out.println(" Chemin du fichier : "+fichier.getPath());
    System.out.println(" Chemin absolu     : "+fichier.getAbsolutePath());
    System.out.println(" Droit de lecture  : "+fichier.canRead()); 
    System.out.println(" Droite d'ecriture : "+fichier.canWrite());
    
    if (fichier.isDirectory() ) {
      System.out.println(" contenu du repertoire ");
      String fichiers[] = fichier.list();
      for(int i = 0; i < fichiers.length; i++) System.out.println("  "+fichiers[i]);
    }     
  }			
}

import java.io.*;

public class TestFile_12 {
  protected String nomFichier;
  protected File fichier;
  
  public TestFile_12(String nomFichier) {
    this.nomFichier = nomFichier;
    fichier = new File(nomFichier);
    traitement();
  }

  public static void main(String args[]) {
    new TestFile_12(args[0]);
  }

  private void traitement() {

    if (!fichier.exists()) { 
      System.out.println("le fichier "+nomFichier+"n'existe pas");
      System.exit(1);
    }      
     
    System.out.println(" Nom du fichier    : "+fichier.getName());
    System.out.println(" Chemin du fichier : "+fichier.getPath());
    System.out.println(" Chemin absolu     : "+fichier.getAbsolutePath());
    System.out.println(" Droit de lecture  : "+fichier.canRead()); 
    System.out.println(" Droite d'ecriture : "+fichier.canWrite());
    
    if (fichier.isDirectory() ) {
      System.out.println(" contenu du repertoire ");
      File fichiers[] = fichier.listFiles();
      for(int i = 0; i < fichiers.length; i++) {
      	
      	if (fichiers[i].isDirectory()) 
      	  System.out.println("  ["+fichiers[i].getName()+"]");      	
      	else
      	  System.out.println("  "+fichiers[i].getName());
      }
    }     
  }			
}

19.6. Les fichiers à accès direct

Les fichiers à accès direct permettent un accès rapide à un enregistrement contenu dans un fichier. Le plus simple pour utiliser un tel type de fichier est qu'il contienne des enregistrements de taille fixe mais ce n'est pas obligatoire. Il est possible dans un tel type de fichier de mettre à jour directement un de ces enregistrements.

La classe RamdonAccessFile encapsule les opérations de lecture/écriture d'un tel fichier. Elle implémente les interfaces DataInput et DataOutput.

Elle possède deux contructeurs qui attendent en paramètre le fichier à utiliser (sous la forme d'un nom de fichier ou d'un objet de type File qui encapsule le fichier) et le mode d'accès.

Le mode est une chaîne de caractères qui doit être égal à «r» ou «rw» selon que le mode soit lecture seule ou lecture/écriture.

Ces deux contructeurs peuvent lever les exceptions suivantes :

• FileNotFoundException si le fichier n'est pas trouvé
• IllegalArgumentException si le mode n'est pas «r» ou «rw»
• SecurityException si le gestionnaire de sécurité empèche l'accès aux fichiers dans le mode précisé

La classe RandomAccessFile possède de nombreuses méthodes writeXXX() pour écrire des types primitifs dans le fichier.

package com.moi.test;

import java.io.RandomAccessFile;

public class TestRandomAccesFile {
  public static void main(String[] args) {
    try {
      RandomAccessFile monFichier = new RandomAccessFile("monfichier.dat", "rw");
      for (int i = 0; i < 10; i++) {
        monFichier.writeInt(i * 100);
      }
      monFichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Elle possède aussi de nombreuses classes readXXX() pour lire des données primitives dans le fichier.

package com.moi.test;

import java.io.RandomAccessFile;

public class TestRandomAccesFile {
  public static void main(String[] args) {
    try {
      RandomAccessFile monFichier = new RandomAccessFile("monfichier.dat", "rw");
      for (int i = 0; i < 10; i++) {
         System.out.println(monFichier.readInt());
      }
      monFichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

  0
  100
  200
  300
  400
  500
  600
  700
  800
  900

Pour naviguer dans le fichier, la classe utilise un pointeur qui indique la position dans le fichier ou les opérations de lecture ou de mise à jour doivent être effectuées. La méthode getFilePointer() permet de connaître la position de ce pointeur et la méthode seek() permet de le déplacer.

La méthode seek() attendant en paramètre un entier long qui réprésentent la position, dans le fichier, précisée en octets. La première position commence à zéro.

package com.moi.test;

import java.io.RandomAccessFile;

public class TestRandomAccesFile {
  public static void main(String[] args) {
    try {
      RandomAccessFile monFichier = new RandomAccessFile("monfichier.dat", "rw");
      // 5 représente le sixième enregistement puisque le premier commence à 0
      // 4 est la taille des données puisqu'elles sont des entiers de type int 
      // (codé sur 4 octets)
      monFichier.seek(5*4);
      System.out.println(monFichier.readInt());
      monFichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

500