La gestion des fichiers

Chapitres traités   

Dans l'étude précédente, nous avons vu comment lire et écrire des données dans un fichier. La gestion des fichiers ne se réduit pas à ceci : La classe File encapsule les fonctionnalités nécessaires pour travailler avec le système de fichiers de la machine de l'utilisateur. Par exemple, vous pouvez utiliser la classe File pour déterminer quand un fichier a été modifié pour la dernière fois ou pour supprimer ou renommer un fichier. En un mot, les classes de flux travaillent sur le contenu des fichiers, alors que la classe File opère le stockage du fichier sur le disque.


Comme c'est souvent le cas en Java, la classe File ne traite que le dénominateur commun aux diverses plateformes. Par exemple, sous Windows, il est possible de lire et de positionner l'indicateur de lecture seule d'un fichier. En revanche, alors qu'il est possible de déterminer qu'il est un fichier caché, on ne peut le cacher sans recourir à une méthode native.

 

Choix du chapitre Explorer le système de fichier - java.io.File

Sécurité des applets

Les méthodes de la classe java.io.File sont suceptibles de déclencher une exception de classe java.lang.SecurityException si, comme dans le contexte d'une applet, le gestionnaire de sécurité actif restreint l'accès au système de fichier.

Chemin relatif

Si le dossier ou le fichier passé en paramètre au constructeur de la classe java.io.File est un chemin relatif, la recherche est effectuée relativement au dossier courant mémorisé par la propriété système user.dir.

Vous pouvez consulter cette propriété système au moyen de la commande suivante :

String s = System.getProperty("user.dir");

Exceptions

Aucun des constructeurs File ne lève d'exception. Cela signifie que l'objet est créé, que le fichier ou le répertoire existe ou non : La création d'un objet File pour un fichier inexistant ne constitue pas une erreur.

Vous pouvez appeler la méthode exists() de l'objet pour déterminer si le fichier ou le répertoire existent.

L'objet File n'existe que comme simple handle destiné à fournir des informations sur ce qu'est potentiellement un fichier ou un répertoire.

Localisation d'un chemin

Il peut s'avérer problématique de travailler des fichiers sous Java car les chemins sont supposés suivre les conventions du système de fichiers local. Les concepteurs de Java ont voulu fournir une abstraction permettant de travailler avec la plupart des caractéristiques de nom de fichier dépendant des systèmes, comme le séparateur de chemin, le périphérique et le répertoire racine.

Sur certains systèmes, Java peut compenser certaines différences comme la direction du séparateur de fichiers (le slash). Par exemple, dans l'implémentation actuelle des plate-formes Windows, Java accepte les chemins avec des barres obliques avant ou arrière. Mais sous Solaris, il n'accepte que les barres obliques avant.

La meilleure solution consiste à assurer que vous suiviez les conventions de manipulation de fichier du système de fichier local. Si votre application a une IHM qui ne fait qu'ouvrir et sauvegarder des fichiers à la demande des utilisateurs, vous devriez pouvoir gérer cette fonctionnalité avec la classe JFileChooser. Celle-ci encapsule une boîte de dialogue graphique de sélection de fichier. Ses méthodes s'occupent pour vous des différences de caractéristiques entre les divers systèmes de fichier.

Si votre application doit manipuler elle-même des fichiers, les choses se compliquent. La classe File contient des attributs static pour les rendre possibles. L'attribut File.separator définit un String spécifiant le séparateur de fichiers de la machine (par exemple, / sur les systèmes Unix et Macintosh, \ sur les systèmes Windows). alors que l'attribut File.separatorChar fournit la même information sous la forme d'un char. File.pathSeparator définit un String séparant les éléments d'un chemin (par exemple : sur un Système Unix, et ; sur les systèmes Windows et Macintosh).

Il est possible d'utiliser de plusieurs façons ces informations dépendantes des systèmes. La façon la plus simplede localiser des chemins consiste à utiliser en interne une convention, par exemple "/", et d'effectuer un remplacement de String pour substituer le caractère de séparation localisé : 

String rep = "premier/deuxième/troisième";
rep = rep.replace('/', File.separatorChar);
File répertoire = new File(rep);

Il est important de se souvenir que Java interprète le caractère anti-slash " \" comme un caractère d'échappement lorsqu'il est utilisé dans un String. Pour obtenir un anti-slash dans un String, vous devez indiquer " \\".

Par ailleurs, certains systèmes d'exploitation utilisent des identificateurs spéciaux pour désigner les "racines" des systèmes de fichier. Par exemple, Windows utilise "C:\". Le cas échéant, la classe File fournit la méthode statique listRoots(), qui renvoie un tableau d'objets File correspondant aux répertoires racines du système de fichiers.

Récapitulatif des méthodes de la classe File
boolean canRead()
Le fichier (ou le répertoire) est-il accessible en lecture ?
boolean canWrite()
Le fichier (ou le répertoire) est-il accessible en écriture ?
boolean canExecute()
Est-ce un fichier de type exécutable ?
boolean createNewFile()
Crée un nouveau fichier vide.
File creatTempFile(String pfx, String sfx)
Méthode statique créant un nouveau fichier, avec le préfixe et le suffixe indiqués, dans le répertoire temporaire par défaut.
boolean delete()
Tente de supprimer le fichier. Renvoie true si le fichier a été supprimé, sinon false.
void deleteOnExit()
Demande la suppression du fichier au moment où la mémoire virtuelle est close.
boolean exists()
Est-ce que le fichier ou le répertoire existe ?
String getAbsolutePath()
Renvoie une chaîne contenant le chemin absolu. Astuce : utiliser plutôt getCanonicalPath().
File getCanonicalFile()
Renvoie un objet File contenant le chemin du fichier dans un format canonique. Ainsi les répertoires "." redondants sont éliminés, le séparateur de répertoire correct est utilisé, et l'utilisation des majuscules/minuscules se conforme aux préférences du système de fichiers.
String getCanonicalPath()
Renvoie une chaîne contenant le chemin du fichier dans un format canonique. Ainsi les répertoires "." redondants sont éliminés, le séparateur de répertoire correct est utilisé, et l'utilisation des majuscules/minuscules se conforme aux préférences du système de fichiers. .
String getName()
Renvoie une chaîne contenant le nom du fichier de l'objet File (sans mention du chemin).
String getParent()
Renvoie une chaîne concernant le répertoire parent de cet objet File. Si cet objet File est un fichier, alors le parent est le répertoire qui le contient. S'il s'agit d'un répertoire, alors le parent est le répertoire parent ou null si vous êtes à la racine.
File getParentFile()
Renvoie un objet File pour le parent de ce répertoire. Voir getParent() pour une définition du "parent".
String getPath()
Renvoie le chemin du fichier ou du répertoire.
long getTotalSpace()
long getFreeSpace()
long getUsableSpace()
Renvoie les tailles : totale, libre et utilisée da la partition en cours.
boolean isAbsolute()
Le chemin du fichier ou du répertoire est-il absolu ?
boolean isDirectory()
S'agit-il d'un répertoire ?
boolean isFile()
S'agit-il d'un fichier ou d'un périphérique ?
boolean isHidden()
S'agit d'un fichier ou d'un répertoire caché ?
long lastModified()
Renvoie l'instant de la dernière modification du fichier (compté en millisecondes depuis le 1er janvier 1970 GMT) ou 0 si le fichier n'existe pas. Utilisez le constructeur Date(long) pour convertir cette valeur en date.
long length()
Renvoie la taille du fichier.
String[] list()
Renvoie un tableau de chaînes contenant les noms des fichiers et répertoires se trouvant dans l'objet File ou null si l'objet File ne représente pas un répertoire.
String[] list(FilenameFilter filtre)
Renvoie un tableau contenant les noms des fichiers et répertoires se trouvant dans l'objet File qui satisfont au filtre ou null s'il n'y en a aucun.
File[] listFiles()
Renvoie un tableau d'objets File correspondant aux fichiers et répertoires contenus dans cet objet File ou null s'il n'y en a pas.
File[] listFiles(FilenameFilter filtre)
Renvoie un tableau d'objets File correspondant aux fichiers et répertoires contenus dans cet objet File qui satisfont au filtre ou null s'il n'y en a pas.
File[] listFiles(FileFilter filtre)
Renvoie un tableau d'objets File correspondant aux fichiers et répertoires contenus dans cet objet File qui satisfont au filtre ou null s'il n'y en a pas.
File[] listRoots()
Renvoie un tableau d'objets File correspondant à tous les fichiers racines existants. Par exemple, sur un système Windows, vous obtenez les objets File représentant les unités de disques installées (aussi bien locales que réseau). Sur un système UNIX, vous obtenez simplement "/".
boolean mkdir()
Crée un répertoire dont le nom est donné par l'objet File. Renvoie true si le répertoire a été créé avec succès, sinon false.
boolean mkdirs()
A la différence de mkdir(), il crée les répertoires parents si nécessaire. Renvoie false si l'un au moins des répertoires requis n'a pu être créé.
boolean renameTo(File nouveau)
Renomme le fichier ou le répertoire.
boolean setLastModified(long instant)
Modifie l'instant de la dernière modification du fichier. Renvoie true si c'est fait, sinon false.
boolean setReadable(boolean état, boolean propriétaire)
boolean setWritable(boolean état, boolean propriétaire)
boolean setExecutable(boolean état, boolean propriétaire)
Définit le fichier comme en lecture seule, modifiable ou de type exécutable. Si le paramètre propriétaire est valide, seul le propriétaire peut intervenir sur ces options, sinon c'est tout le monde.
URL toURL()
Convertit l'objet File en un fichier URL.
java.io.FilenameFilter
boolean accept(File repFiltre, String nom)
Devrait être redéfini de façon à renvoyer true si le fichier correspond au critère du filtre.
java.io.FileFilter
boolean accept(File fichier)
Devrait être redéfini de façon à renvoyer true si le fichier correspond au critère du filtre.
 

La classe java.io.File encapsule l'accès aux informations concernant un fichier ou une entrée de répertoire du système de fichiers. Elle peut être utilisée pour obtenir les attributs d'un fichier, lister les entrées d'un répertoire et effectuer certaines opérations de base sur le système de fichier, comme supprimer un fichier ou créer un répertoire. Lorsque l'objet File effectue ce genre d'opérations, il ne fournit pas d'accès direct pour lire ou écrire des données dans le fichier : ces opérations sont effectuées par des flux spécialisés.

La description des chemins d'accès (séparateurs, description des disques...) utilisée par le constructeur et les méthodes de cette classe utilisent les conventions du système sur lequel est exécutée la JVM.

 

Choix du chapitre Création d'une instance (d'un objet) de type java.io.File

Le constructeur le plus simple pour un objet File prend un nom de fichier complet. En l'absence de chemin, Java utilise le répertoire courant. Par exemple :

File fichier = new File("test.txt");

donne accès à un objet fichier de ce nom dans le répertoire courant, c'est-à-dire le répertoire où se trouve le processus qui exécute la machine virtuelle. Si vous avez lancé la machine virtuelle à partir de la ligne de commande, c'est le répertoire à partir duquel vous avez lancé l'exécutable Java.

Il s'agit ici d'un chemin relatif. Un appel à ce constructeur ne crée pas un fichier de ce nom s'il n'existe pas. En fait, créer un fichier quand nous possédons un objet File se fait par l'un des constructeurs des classes flux ou par la méthode createNewFile() de la classe File. La méthode createNewFile() ne va créer de fichier que s'il n'existe pas déjà de fichier de ce nom, et renvoie un boolean pour indiquer si cela c'est réalisé ou pas.

Par ailleurs, si l'on possède un objet File, la méthode exists() de la classe File indique s'il existe un fichier de ce nom.

Dans l'exemple suivant, nous spécifions un chemin en plus :

File fichier = new File("/tmp/test.txt");

Attention, vu que nous commençons par /, il s'agit ici d'un chemin absolue, c'est-à-dire que nous sommes en relation avec un fichier éventuel <test.txt> qui se trouve dans le répertoire <tmp> qui lui même se situe au niveau de la racine du système de fichiers.

Une version surchargée du constructeur File permet de spécifier les chemins des répertoires et des fichiers en tant qu'objets String individuels :

File fichier = new File("tmp", "test.txt");

Une autre variante permet de spécifier le nom du répertoire avec un objet File et le nom du fichier avec un objet String :

File répertoire = new File("tmp");
File fichier = new File(répertoire, "test.txt");

De manière un peu désordonnée, un objet File peut représenter soit un fichier, soit un répertoire. Les méthodes isDirectory() et isFile() permettent de savoir s'il s'agit d'un répertoire ou d'un fichier. C'est assez choquant - dans un contexte orienté objet, on s'attend plutôt à une classe distincte Directory, qui serait une extension de la classe File.

Dans les deux exemples précédents, vu que nous ne débutons pas par un séparateur, il s'agit à chaque fois d'un répertoire relatif au dossier courant.

File répertoire = new File("/tmp");

Par contre ici, nous sommes en relation avec un répertoire absolue, c'est à dire qu'il se trouve au niveau de la racine du système de fichiers.

Donc, pour instancier un objet représentant un répertoire, il suffit de donner le nom du répertoire au constructeur File. En reprenant l'exemple précédent, mais en respectant cette fois-ci le séparateur déterminé par le système d'exploitation, voici ce que nous pouvons écrire :

File répertoire = new File(File.separator + "tmp");

Si le répertoire n'existe pas, la méthode mkdir() va le créer :

File répertoire = new File(File.separator + "tmp");
répertoire.mkdir();

Si un objet File représente un répertoire, nous pouvons utiliser list() pour construire un tableau de noms de fichiers de ce répertoire.

Utilisez toujours les objets File, et non des chaînes, lorsque vous manipulez les noms de fichiers ou de répertoires. Par exemple, la méthode equals() de la classe File sait que certains systèmes de fichiers ne prennent pas garde à la casse et que placer un signe / dans un nom de répertoire n'a pas d'importance.

 

Choix du chapitre Opération sur les fichiers

Dés que l'on dispose d'un objet File valide, il est possible de l'utiliser pour obtenir certaines informations sur le fichier ou le répertoire, et lui appliquer des opérations standard.

Plusieurs méthodes permettent de récupérer les attributs du fichier. Par exemple, la méthode isFile() renvoie true lorsque l'objet File désigne un fichier, alors que la méthode isAbsolute() indique si le chemin de File est absolu ou relatif.

 

Les chemins

Les différents composants de chemin d'un objet File sont disponibles par l'intermédiaire des méthodes suivantes : getName(), getPath(), getAbsolutePath() et getParent().getName() renvoie un String concernant le nom du fichier sans son répertoire. getPath() renvoie le nom du répertoire sans le nom du fichier. Si l'objet File possède un chemin absolu, getAbsolutePath() renvoie ce chemin. Sinon, cette méthode renvoie le chemin relatif concaténé au répertoire courant. Enfin, getParent() renvoie le répertoire dans lequel se trouve le fichier.

La chaîne renvoyée par getPath() ou getAbsolutePath() ne respecte pas les conventions de casse de caractères du système de fichiers sous-jacent. Nous pouvons récupérer la version personnelle ou "canonique" du chemin en utilisant la méthode getCanonicalPath(). Par exemple sous Windows, nous pouvons créer un objet File avec getAbsolutePath() donnant C:\Autoexec.bat, mais avec getCanonicalPath() donnant C:\AUTOEXEC.BAT. Ceci permet de comparer des noms de fichiers pouvant avoir été indiqués sous des conventions de casse différentes.

Si vous utilisez le slash comme séparateur de répertoires sous Windows quand vous construisez un objet File, la méthode getAbsolutePath() renvoie un nom de fichier contenant des slashs qui vont surprendre les utilisateurs de Windows. Il vaut mieux utiliser la méthode getCanonicalPath() qui substitue des antislash aux slash.

 

Heure de modification et taille des fichiers

Il est possible d'obtenir ou de définir l'heure de modification d'un fichier ou d'un répertoire avec les méthodes lastModified() et setLastModified(). La valeur est un long représentant le nombre de millisecondes écoulées depuis la date du 1 janvier 1970 à 0 heure GMT. Nous pouvons également obtenir la taille en octets du fichier en utilisant length().

 

Liste d'un répertoire

Si l'objet File désigne un répertoire, il est possible de récupérer la liste des fichiers de ce répertoire en utilisant la méthode list() ou la méthode listFiles() :

String[] nomFichiers = fichier.list();
File[] fichiers =fichier.listFiles();

La méthode list() renvoie un tableau d'objets String contenant les noms de fichiers. listFiles() renvoie un tableau d'objet File. Les fichiers ne sont jamais assurés d'apparaître dans un ordre donné (par exemple alphabétique). On utilisera les collections pour trier alphabétiquement les chaînes de caractères.

 

Créer, renommer ou effacer des fichiers ou des répertoires

Si l'objet File fait référence à un répertoire inexistant, il est possible de le créer en utilisant la méthode mkdir() ou la méthode mkdirs(). La méthode mkdir() crée un seul répertoire, tandis que mkdirs() crée tous les répertoires spécifiés dans l'objet File. Les méthodes renameTo() et delete() permettent respectivement de renommer un répertoire ou un fichier et de détruire un fichier ou un répertoire.

Bien que nous puissions créer des fichiers en utilisant l'objet File, nous utilisons plutôt un FileOutputStream ou un FileWriter. La méthode createNewFile() constitue une exception ; elle peut en effet être utilisée pour créer un fichier de taille nulle (vierge) à l'emplacement pointé par l'objet File. Cette méthode garantit que l'opération est "atomique" par rapport à toutes autre création de fichier. createNewFile() renvoie une valeur booléenne indiquant si le fichier a bien été créé.

 

Fichier et URL

La méthode toURL() convertit un chemin de fichier en un objet URL "file:". Rappelons que la classe URL correspond à une abstraction permettant de pointer n'importe quel objet du NET. La conversion d'une référence File en une URL peut s'avérer utile pour des raisons de cohérence avec les routines plus générales traitant des URL.

 

Choix du chapitre Exemple récapitulatif 

package test;

import java.io.*;
import static java.lang.System.*;
import java.util.Date;

public class Main {
   public static void main(String[] args) throws IOException {
      out.println("Répertoire courant : "+System.getProperty("user.dir"));
      File rep = new File(".");
      out.println("Chemin relatif : "+rep.getPath());
      out.println("Chemin absolu : "+rep.getAbsolutePath());
      out.println("Chemin canonique : "+rep.getCanonicalPath());
      for (File élément: rep.listRoots())
         out.println("Racine : "+élément);
      
      for (File élément : rep.listFiles())
         if (élément.isDirectory()) {
            out.print(élément.getName()+"\t");
            if (élément.getName().length()<8) out.print("\t");
            out.println("<REP>");
         }

      for (File élément : rep.listFiles()) 
         if (élément.isFile()){
            out.print(élément.getName()+"\t");
            if (élément.getName().length()<8) out.print("\t");
            out.printf("%tc", new Date(élément.lastModified()));
            out.printf("\t%10d octets\n", élément.length());
         }
   }
}

Résultats

init:
deps-jar:
Compiling 1 source file to M:\netbeans-5.0\travail\Test\test\build\classes
compile:
run:

Répertoire courant : M:\netbeans-5.0\travail\Test\test
Chemin relatif : .
Chemin absolu : M:\netbeans-5.0\travail\Test\test\.
Chemin canonique : M:\netbeans-5.0\travail\Test\test
Racine : C:\
Racine : D:\
Racine : E:\
Racine : F:\
Racine : G:\
Racine : H:\
Racine : I:\
Racine : K:\
Racine : L:\
Racine : M:\
Racine : N:\
Racine : O:\
Racine : U:\
build          <REP>
nbproject      <REP>
src            <REP>
test           <REP>
tmp            <REP>
build.xml      jeu. mars 09 14:28:55 CET 2006     3349 octets
manifest.mf    jeu. mars 09 14:28:56 CET 2006       85 octets
tmp.txt        jeu. mars 09 14:38:13 CET 2006        0 octets

BUILD SUCCESSFUL (total time: 0 seconds)

 

Choix du chapitre Filtres de fichiers

Plutôt que de recenser tous les fichiers se trouvant dans un répertoire, nous pouvons passer un objet FilenameFilter en paramètre de la méthode list() ou de la méthode listFiles() pour racourcir la liste. Ces objets sont simplement des instances d'une classe qui satisfait à l'interface FilenameFilter. Pour implémenter l'interface FilenameFilter, il suffit à une classe de redéfinir une méthode appelée accept().

La méthode accept() accepte deux arguments qui vous sont précisez dans la colonne de droite. Attention, le premier argument correspond au répertoire sur lequel porte le filtre, alors que le deuxième argument est le nom du fichier (ou du répertoire) contenu dans ce répertoire.

Il existe également une deuxième interface FileFilter qui n'est utilisée que par la méthode listFiles() de la classe File. Nous devons également implémenter cette interface en redéfinissant la méthode accept().

Cette fois-ci, la méthode accept() ne possède qu'un seul argument qui correspond au fichier (ou au répertoire) faisant parti du répertoire sur lequel porte le filtre.

Interface java.io.FilenameFilter

Nous allons mettre en oeuvre ces deux types de filtres. Le premier filtre permettra de laisser passer les fichiers ou les répertoires qui commence par une lettre désignée au moment de la construction du filtre. L'interface choisie pour réaliser ce filtre est FilenameFilter. Dans le programme, une première liste du répertoire courant est proposée, mais sans filtre. Ensuite, nous redemandons une nouvelle fois la liste en proposant l'affichage des répertoires ou des fichiers qui commencent par la lettre 'b'.

package file;

import java.io.*;
import static java.lang.System.*;
import java.util.Date;

public class Main {
   public static void main(String[] args) throws IOException {
      File rep = new File(".");
      out.println("Non filtré........................................................................");
      for (File élément : rep.listFiles()) {
         out.print(élément.getName()+"\t");
         if (élément.getName().length()<8) out.print("\t");
         if (élément.isDirectory()) out.print("<REP>");
         out.printf("\t%tc", new Date(élément.lastModified()));
         out.printf("\t%5d octets\n", élément.length());
      }
      out.println("Filtré...............................................................................");
      for (File élément : rep.listFiles(new Filtre('b'))) {
         out.print(élément.getName()+"\t");
         if (élément.getName().length()<8) out.print("\t");
         if (élément.isDirectory()) out.print("<REP>");
         out.printf("\t%tc", new Date(élément.lastModified()));
         out.printf("\t%5d octets\n", élément.length());
      }      
   }
}

class Filtre implements FilenameFilter {
   private char lettre;
   
   public Filtre(char lettreDébut) {
      lettre = lettreDébut;
   }
   public boolean accept(File repFiltre, String nom) {
      return nom.charAt(0)==lettre;
   }
}

init:
deps-jar:
Compiling 1 source file to C:\netbeans-5.0\travail\File\build\classes
compile:
run:


Non filtré...............................................................
.cvsignore              ven. mars 10 11:56:50 CET 2006      7 octets
build           <REP>   ven. mars 10 11:56:47 CET 2006      0 octets
build.xml               ven. mars 10 11:48:17 CET 2006   3349 octets
manifest.mf             ven. mars 10 11:48:19 CET 2006     85 octets
nbproject       <REP>   ven. mars 10 11:48:17 CET 2006      0 octets
newfile                 ven. mars 10 14:05:13 CET 2006    765 octets
src             <REP>   ven. mars 10 11:48:17 CET 2006      0 octets
test            <REP>   ven. mars 10 11:48:17 CET 2006      0 octets
Filtré...................................................................
build           <REP>   ven. mars 10 11:56:47 CET 2006      0 octets
build.xml               ven. mars 10 11:48:17 CET 2006   3349 octets

BUILD SUCCESSFUL (total time: 0 second

Interface java.io.FileFilter

Cette fois-ci, le filtre ne devra laisser passer que les répertoires qui commence par une lettre désignée au moment de la construction du filtre. L'interface choisie pour réaliser ce filtre est FileFilter. Encore une foic, dans le programme, une première liste du répertoire courant est proposée, mais sans filtre. Ensuite, nous redemandons une nouvelle fois la liste en proposant l'affichage des répertoires qui commencent par la lettre 'b'. 

package file;

import java.io.*;
import static java.lang.System.*;
import java.util.Date;

public class Main {
   public static void main(String[] args) throws IOException {
      File rep = new File(".");
      out.println("Non filtré........................................................................");
      for (File élément : rep.listFiles()) {
         out.print(élément.getName()+"\t");
         if (élément.getName().length()<8) out.print("\t");
         if (élément.isDirectory()) out.print("<REP>");
         out.printf("\t%tc", new Date(élément.lastModified()));
         out.printf("\t%5d octets\n", élément.length());
      }
      out.println("Filtré...............................................................................");
      for (File élément : rep.listFiles(new Filtre('b'))) {
         out.print(élément.getName()+"\t");
         if (élément.getName().length()<8) out.print("\t");
         if (élément.isDirectory()) out.print("<REP>");
         out.printf("\t%tc", new Date(élément.lastModified()));
         out.printf("\t%5d octets\n", élément.length());
      }      
   }
}

class Filtre implements FileFilter {
   private char lettre;
   
   public Filtre(char lettreDébut) {
      lettre = lettreDébut;
   }
   public boolean accept(File fichier) {
      return fichier.getName().charAt(0)==lettre && fichier.isDirectory();
   }   
}

init:
deps-jar:
Compiling 1 source file to C:\netbeans-5.0\travail\File\build\classes
compile:
run:


Non filtré..............................................................
.cvsignore              ven. mars 10 11:56:50 CET 2006      7 octets
build           <REP>   ven. mars 10 11:56:47 CET 2006      0 octets
build.xml               ven. mars 10 11:48:17 CET 2006   3349 octets
manifest.mf             ven. mars 10 11:48:19 CET 2006     85 octets
nbproject       <REP>   ven. mars 10 11:48:17 CET 2006      0 octets
src             <REP>   ven. mars 10 11:48:17 CET 2006      0 octets
test            <REP>   ven. mars 10 11:48:17 CET 2006      0 octets
Filtré..................................................................
build           <REP>   ven. mars 10 11:56:47 CET 2006      0 octets

BUILD SUCCESSFUL (total time: 0 seconds)