Section courante

A propos

Section administrative du site

Gestion des fichiers et entrée/sortie

Le langage de programmation Java prend en charge les entrées/sorties depuis la toute première version. Cependant, en raison du fort désir de Java pour l'indépendance de la plate-forme, les versions antérieures de la fonctionnalité d'entrée/sortie mettaient l'accent sur la portabilité plutôt que sur la fonctionnalité. En conséquence, ils n'étaient pas toujours faciles à travailler.

Les entrées/sorties Java classiques

La classe File est la pierre angulaire de la manière originale de Java d'effectuer les entrées/sorties de fichier. Cette abstraction peut représenter à la fois des fichiers et des répertoires, mais ce faisant, elle est parfois un peu difficile à gérer et conduit à un code comme celui-ci :

  1. import java.io.File;
  2.  
  3. class Main {
  4.   public static void main (String[] args)  {
  5.      /* Demande un objet fichier pour représenter le répertoire personnel de l'utilisateur */
  6.     File homedir=new File(System.getProperty("user.home"));
  7.  
  8.      /* Crée un objet pour représenter un fichier de configuration (devrait déjà être présent dans le répertoire personnel) */
  9.     File f=new File(homedir,"app.conf");
  10.  
  11.      /* Vérifiez que le fichier existe, qu'il est vraiment un fichier et qu'il est lisible */
  12.     if(f.exists() && f.isFile() && f.canRead()) {
  13.        /* Créer un objet fichier pour un nouveau répertoire de configuration */
  14.       File configdir = new File(f,".configdir");
  15.        /* Et le crée */
  16.       configdir.mkdir();
  17.        /* Enfin, déplacez le fichier de configuration vers son nouvel emplacement */
  18.       f.renameTo(new File(configdir,".config"));   
  19.     }
  20.   }
  21. }

Cette exemple montre une partie de la flexibilité possible avec la classe File, mais démontre également certains des problèmes avec l'abstraction. Il est très général et nécessite donc de nombreuses méthodes pour interroger un objet File afin de déterminer ce qu'il représente réellement et ses capacités.

Fichiers

La classe File contient un très grand nombre de méthodes, mais certaines fonctionnalités de base (notamment un moyen de lire le contenu réel d'un fichier) ne sont pas et n'ont jamais été fournies directement. Voici un bref résumé des méthodes de la classe File :

  1. import java.io.File;
  2. import java.net.URI;
  3.  
  4. class Main {
  5.   public static void main (String[] args) {
  6.        File homedir=new File(System.getProperty("user.home"));
  7.      File f=new File(homedir,"app.conf");
  8.      File rep=new File(f,".configdir");
  9.      boolean resultat;
  10.      
  11.      /* Gestion des permissions : */
  12.      boolean peuExecuter = f.canExecute();
  13.      boolean peuLire     = f.canRead();
  14.      boolean peuEcrire   = f.canWrite();
  15.      
  16.      resultat = f.setReadOnly();
  17.      resultat = f.setExecutable(true);
  18.      resultat = f.setReadable(true);
  19.      resultat = f.setWritable(true);
  20.      
  21.      /* Différentes vues d'un nom de fichier : */
  22.      File fichierAbsolue     = f.getAbsoluteFile();
  23.      File fichierCanonique   = f.getCanonicalFile();
  24.      String nomAbsolue       = f.getAbsolutePath();
  25.      String nomCanonique     = f.getCanonicalPath();
  26.      String nom              = f.getName();
  27.      String nomParent        = f.getParent();
  28.      URI fichierURI          = f.toURI();
  29.      
  30.      /* Fichier de méta-données : */
  31.      boolean existes         = f.exists();
  32.      boolean estceAbsolue    = f.isAbsolute();
  33.      boolean estceRepertoire = f.isDirectory();
  34.      boolean estceFichier    = f.isFile();
  35.      boolean estceCache      = f.isHidden();
  36.      long heureModification  = f.lastModified();
  37.      boolean resultatOk      = f.setLastModified(heureModification);
  38.      long longueurFichier    = f.length();
  39.      
  40.      /* Opération de gestion de fichier : */
  41.      File fichierDest        = new File(f,"nouveaunom.txt");
  42.      boolean renomme         = f.renameTo(fichierDest);
  43.      boolean supprime        = f.delete();
  44.      
  45.      /* Créer n'écrasera pas le fichier existant : */
  46.      boolean creationOk      = f.createNewFile();
  47.      
  48.      /* Gestion des fichier temporaire : */
  49.      File temporaire         = File.createTempFile("mon-temp",".tmp");
  50.      temporaire.deleteOnExit();
  51.      
  52.      /* Gestion de répertoire */
  53.      boolean creeRepertoire  = rep.mkdir();
  54.      String[] nomsFichier    = rep.list();
  55.      File[] fichiers         = rep.listFiles();
  56.   }
  57. }

La classe File contient également quelques méthodes ne convenant pas parfaitement à l'abstraction. Ils impliquent en grande partie d'interroger le système de fichiers (par exemple, demander l'espace libre disponible) sur lequel le fichier réside :

  1. import java.io.File;
  2.  
  3. class Main {
  4.   public static void main (String[] args) {
  5.        File homedir=new File(System.getProperty("user.home"));
  6.      File f=new File(homedir,"app.conf");
  7.      
  8.      long libre = f.getFreeSpace();
  9.      long total = f.getTotalSpace();
  10.      long utilise = f.getUsableSpace();
  11.  
  12.      File[] racines = File.listRoots(); /* Toutes les racines de système de fichiers disponibles */
  13.   }
  14. }

Les flux de données (Stream)

L'abstraction de flux de données d'entrée/sorties (à ne pas confondre avec les flux utilisés lors du traitement des API de Java 8 Collection) était présente dans Java 1.0, comme moyen de traiter le flux de données séquentiel d'octets à partir de disques ou d'autres sources. Le coeur de cette API est une paire de classes abstraites, InputStream et OutputStream. Ceux-ci sont très largement utilisés, et en fait les flux de données d'entrée et de sortie standard, appelés System.in et System.out, sont des flux de données de ce type. Ce sont des champs publiques et statiques de la classe System, et sont souvent utilisés même dans les programmes les plus simples :

System.out.println("Bonjour Gladir.com!");

Des sous-classes spécifiques de flux de données, y compris FileInputStream et FileOutputStream, peuvent être utilisées pour opérer sur des octets individuels dans un fichier - par exemple, en comptant toutes les fois où le code ASCII 103 (minuscule g) apparaît dans un fichier :

  1. import java.io.FileInputStream;
  2. import java.io.IOException;
  3.  
  4. class Main {
  5.   public static void main (String[] args) {
  6.        try(FileInputStream entree = new FileInputStream("/Users/gladir/texte.txt")) {
  7.       byte[] tampon=new byte[4096];
  8.       int longueur,compteur=0;
  9.       while((longueur = entree.read(tampon)) > 0) {
  10.        for(int i=0;i < longueur; i++) if(tampon[i] == 103) compteur++;
  11.       }
  12.       System.out.println("'g' est vue: "+compteur);
  13.      } catch(IOException e) {
  14.       e.printStackTrace();
  15.      }
  16.   }
  17. }

Cette approche du traitement des données sur disque manque de flexibilité - la plupart des développeurs pensent en termes de caractères et non d'octets. Pour permettre cette situation, les flux de données sont généralement combinés avec les classes Reader et Writer de haut niveau, fournissant un niveau d'interaction de flux de caractères, plutôt que le flux de données d'octets de bas niveau fourni par InputStream et OutputStream et leurs sous-classes.

Lectures et écritures

En passant à une abstraction traitant des caractères plutôt que des octets, les développeurs se voient présenter une API beaucoup plus familière et cachant de nombreux problèmes liés au codage de caractères, à Unicode,... Les classes Reader et Writer sont destinées à superposer les classes de flux de données d'octets et à supprimer le besoin de gestion de bas niveau des flux de données d'entrée/sortie. Ils ont plusieurs sous-classes étant souvent utilisées pour se superposer, telles que :



Dernière mise à jour : Vendredi, le 13 novembre 2020