7.2 Fichiers

La lecture et l'écriture d'octets sur un fichier se fait à l'aide des classes FileInputStream et FileOutputStream, sous-types respectifs de InputStream et OutputStream. L'exemple suivant montre une application qui copie un fichier dans un autre (dont les noms sont donnés sur la ligne de commande), octet par octet ; si les deux noms de fichiers ne sont pas donnés sur la ligne de commande, on utilise les flots standards System.in, et System.out, ce qui est possible car FileOutputStream et PrintStream sont des sous-types de OutputStream.

  public static void main(String[] args)
    throws IOException {
    InputStream in = System.in;
    OutputStream out = System.out;
    if (args.length > 0) 
      in = new FileInputStream(args[0]);
    if (args.length > 1)
      out = new FileOutputStream(args[1]);
    copier(in, out);
  }

En l'absence de récupération de l'exception IOException, la méthode main doit déclarer qu'elle est susceptible de déclencher cette exception.

Pour concaténer des octets à la fin d'un fichier (au lieu d'écrire en écrasant éventuellement son contenu), on utilise un autre constructeur de FileOutputStream, avec l'argument supplémentaire true :

    if (args.length > 1) 
      out = new FileOutputStream(args[1], true);

La classe File a pour objet des chemins d'accès à des fichiers ou à des répertoires (et non les fichiers eux-mêmes). Cette classe est utile pour obtenir diverses propriétés des fichiers (savoir si un chemin désigne un fichier ordinaire ou un répertoire, est accessible en lecture ou en écriture, etc.) :

 File cheminRepertoire =
   new File("/usr/local/www/doc/java/jdk1.1.5/docs");
 File cheminFichier =
   new File(cheminRepertoire, "index.html");
   // ...
   if (cheminRepertoire.isDirectory() &&
       cheminFichier.canRead()) {
     // ...
   }

La méthode length, appliquée à un objet de type File et qui retourne un long, détermine la taille d'un fichier en nombre d'octets.

7.2.0.0.1 Modes d'accès à un fichier

Si un accès direct à une position quelconque du fichier est nécessaire, on devra utiliser la classe RandomAccessFile, qui fonctionne à la fois en écriture et en lecture, permettant de sauvegarder, puis de restituer, la position d'une opération dans le fichier. Le second d'argument du constructeur est une chaîne qui spécifie le mode d'accès : "rw" indique un accès en lecture ("r" pour « read ») et en écriture ("w" pour « write »), et "r" indique un accès en lecture seulement.

On obtient la position courante à l'aide de la méthode getFilePointer, qui retourne un long. On peut se positionner à l'aide de la méthode seek, qui a un paramètre entier de type long indiquant un déplacement, compté en octets, à partir du début du fichier.

  RandomAccessFile inOut = 
      new RandomAccessFile("out.txt", "rw"); 
  inOut.seek(inOut.length());       // positionnement à la fin
  inOut.writeBytes("etc., ...");    // ajout de caractères
  inOut.seek(0);                    // positionnement au début
  inOut.writeBytes("Au début");     // écrase le début !
  inOut.seek(0);                    // positionnement au début
  String s = inOut.readLine();      // lecture d'une ligne

Comme Java ne permet pas d'hériter de plusieurs classes, RandomAccessFile n'est une extension ni de InputStream ni de OutputStream. Par contre, elle réalise à la fois les interfaces DataInput et DataOutput.

7.2.0.0.2 Tableaux d'octets

Le modèle des flots peut être utilisé afin d'accéder en lecture ou en écriture à un tableau d'octets, de façon analogue à un fichier. Supposons que l'on dispose d'un tableau d'octets data (reçu par exemple par une communication UDP sur l'Internet). La classe ByteArrayInputStream permet de construire un flot de lecture à partir de ce tableau data.

  byte[] data = ...;

  ByteArrayInputStream in =
    new ByteArrayInputStream(data);