Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Utilisation des classes Path et Files en Java

Vous pouvez utiliser les classes Java Path et Files pour travailler avec des fichiers.

  • La classe Path permet de créer des objets contenant des informations sur les fichiers et les répertoires, tels que leurs emplacements, leurs tailles, leurs dates de création et même leur existence.
  • La classe Files est utilisée pour effectuer des opérations sur les fichiers et les répertoires, tels que les supprimer, déterminer leurs attributs et créer des flux d'entrée et de sortie.

Vous pouvez inclure l'instruction suivante dans un programme Java pour utiliser les classes Path et Files:

                                import java.nio.file.*;
                            
  nio dans java.nio signifie nouvelle entrée/sortie car ses classes sont «nouvelles» en ce sens qu’elles n’ont pas été développées avant Java 7.

Créer un chemin

Pour créer un chemin d'accès, vous devez d'abord déterminer le système de fichiers par défaut sur l'ordinateur hôte à l'aide d'une instruction telle que:

                                FileSystem fs = FileSystems.getDefault();
                            

Cette instruction crée un objet FileSystem à l'aide de la méthode getDefault() de la classe FileSystems. La déclaration utilise deux classes différentes. La classe FileSystem, sans s, est utilisée pour instancier l'objet. FileSystems, avec s, est une classe qui contient des méthodes fabrique (factory methods), qui aident à la création d'objets.

Après avoir créé un objet FileSystem, vous pouvez définir un chemin en utilisant la méthode getPath() avec:

                                Path chemin = fs.getPath("D:\\DEV-INFO\\SGF\\intro.txt");
                            

Rappelez-vous que la barre oblique inverse est utilisée dans le cadre d'une séquence d'échappement en Java. (Par exemple, '\ n' représente un caractère de nouvelle ligne.) Ainsi, pour saisir une barre oblique inverse en tant que délimiteur de chemin dans une chaîne, vous devez taper deux barres obliques inverses pour indiquer une seule barre oblique inversée.

Une alternative consiste à utiliser la méthode getSeparator() de la classe FileSystem. Cette méthode renvoie le séparateur correct pour le système d'exploitation actuel. Par exemple, vous pouvez créer un chemin identique au précédent en utilisant une instruction telle que la suivante :

                                Path chemin = fs.getPath("D:" + fs.getSeparator() + "DEV-INFO" +fs.getSeparator() + "SGF" + fs.getSeparator() +"intro.txt");
                            

Une autre façon de créer un chemin consiste à utiliser la classe Paths (notez que le nom se termine par s). La classe Paths est une classe d'assistance qui élimine la nécessité de créer un objet FileSystem. La méthode get() de la classe Paths appelle la méthode getPath() du système de fichiers par défaut sans vous obliger à instancier un objet FileSystem. Vous pouvez créer un objet Path à l'aide de l'instruction suivante

                                Path chemin = Paths.get("D:\\DEV-INFO\\SGF\\intro.txt");
                            

Une fois le chemin créé, vous utilisez son identificateur (dans ce cas, chemin) pour faire référence au fichier et y effectuer des opérations.

Chaque chemin est absolu ou relatif.

  •   Un chemin absolu est un chemin complet; aucune autre information n'est nécessaire pour localiser un fichier sur un système. Un chemin complet tel que D:\DEV-INFO\SGF\intro.txt est un chemin absolu.
  •   Un chemin relatif dépend d'autres informations sur le chemin. Un chemin simple tel que intro.txt est relatif. Lorsque vous travaillez avec un chemin ne contenant qu'un nom de fichier, le fichier est supposé se trouver dans le même dossier que le programme qui l'utilise.

Récupérer des informations sur un chemin

Le tableau suivant récapitule plusieurs méthodes de classe Path utiles.

MéthodeDescription
String toString()Renvoyer la représentation de la chaîne du chemin, en éliminant les doubles barres obliques inverses.
Path getFileName()Renvoyer le fichier ou le répertoire désigné par ce chemin; c'est le dernier élément de la séquence d'éléments nommés
int getNameCount()Renvoyer le nombre d'éléments nommés dans le chemin.
Path getName(int)Renvoyer le nom dans la position du chemin spécifié par le paramètre entier

Les éléments d’un chemin sont accessibles via un index. L'élément de niveau supérieur de la structure du répertoire est situé à l'index 0;

L'élément le plus bas de la structure est accessible par la méthode getName() et possède un index égal à un de moins que le nombre d'éléments de la liste. Vous pouvez utiliser la méthode getNameCount() pour extraire le nombre de noms de la liste et la méthode getName(int) pour extraire le nom à la position spécifiée par l'argument.

Exemple 1 :
                                    import java.nio.file.*;

                                    public class Test {
                                        public static void main(String args[]) {
                                            Path chemin = Paths.get("/Volumes/Sauvegarde/intro.txt");
                                            int count = chemin.getNameCount();
                                            System.out.println("le chemin est " + chemin.toString());
                                            System.out.println("le nom du fichier est  " + chemin.getFileName());
                                            System.out.println("Il y a " + count + " éléments dans cet chemin");
                                            for (int x = 0; x < count; x++)
                                                System.out.println("Elément " + x + " : " + chemin.getName(x));
                                        }
                                    }
                            
le chemin est /Volumes/Sauvegarde/intro.txt
le nom du fichier est intro.txt
Il y a 3 éléments dans cet chemin
Elément 0 : Volumes
Elément 1 : Sauvegarde
Elément 2 : intro.txt

Conversion d'un chemin relatif en chemin absolu

La méthode toAbsolutePath() convertit un chemin relatif en chemin absolu.

Exemple 2 :
                                    import java.nio.file.*;

                                    public class Test {
                                        public static void main(String args[]) {
                                            Path chemin = Paths.get("intro.txt");
                                            Path absolu = chemin.toAbsolutePath();
                                            System.out.println("chemin absolu : " + absolu.toString());
                                        }
                                    }
                            
chemin absolu : /Applications/MAMP/htdocs/articles/intro.txt

Vérification de l'accessibilité des fichiers

Pour vérifier qu'un fichier existe et que le programme peut y accéder si nécessaire, vous pouvez utiliser la méthode checkAccess(). L'instruction d'importation suivante vous permet d'accéder à des constantes pouvant être utilisées comme arguments de la méthode:

                                import static java.nio.file.AccessMode.*;
                            

En supposant que vous ayez déclaré un chemin nommé monchemin, la syntaxe que vous utilisez avec checkAccess() est la suivante:

                                monchemin.getFileSystem().provider().checkAccess();
                            

Vous pouvez utiliser l'un des éléments suivants comme arguments de la méthode checkAccess():

  • Aucun argument - Vérifie que le fichier existe
  • READ - vérifie que le fichier existe et que le programme est autorisé à le lire.
  • WRITE - vérifie que le fichier existe et que le programme est autorisé à écrire dans le fichier.
  • EXECUTE - Vérifie que le fichier existe et que le programme est autorisé à exécuter le fichier

Vous pouvez utiliser plusieurs arguments pour la méthode checkAccess(), séparés par des virgules. Si le fichier nommé dans l'appel de méthode est inaccessible, une exception IOException est levée.

Exemple 3 :
                                    import java.io.IOException;
                                    import java.nio.file.*;
                                    import static java.nio.file.AccessMode.*;
                                    
                                    public class Test {
                                        public static void main(String args[]) {
                                            Path chemin = Paths.get("intro.txt");
                                            try {
                                                chemin.getFileSystem().provider().checkAccess(chemin, READ, EXECUTE);
                                                System.out.println("Le fichier peut être lu et exécuté");
                                            } catch (IOException e) {
                                                System.out.println("Le fichier ne peut pas être utilisé");
                                            }
                                        }
                                    }
                            
Le fichier ne peut pas être utilisé
-rw-r--r--     1   mostafaessaddouki   admin   12 14 Sep  02:19  intro.txt

Suppression d'un chemin

La méthode delete() de la classe Files accepte un paramètre Path et supprime le dernier élément (fichier ou répertoire) d'un chemin ou lève une exception en cas d'échec de la suppression. Par exemple:

  • Si vous essayez de supprimer un fichier qui n'existe pas, une exception NoSuchFileException est levée.
  • Un répertoire ne peut être supprimé que s'il est vide. Si vous essayez de supprimer un répertoire contenant des fichiers, une exception DirectoryNotEmptyException est levée.
  • Si vous essayez de supprimer un fichier sans y avoir la permission, une exception SecurityException est levée.
  • D'autres erreurs d'entrée/sortie entraînent une exception IOException.
Exemple 4 :
                                    import java.io.IOException;
                                    import java.nio.file.*;
                                    
                                    public class Test {
                                        public static void main(String args[]) {
                                            Path chemin = Paths.get("intro.txt");
                                            try {
                                                Files.delete(chemin);
                                                System.out.println("Le fichier ou le répertoire est supprimé");
                                            } catch (NoSuchFileException e) {
                                                System.out.println("Aucun fichier ou répertoire de ce nom");
                                            } catch (DirectoryNotEmptyException e) {
                                                System.out.println("Le répertoire n'est pas vide");
                                            } catch (SecurityException e) {
                                                System.out.println("Pas de permission pour supprimer");
                                            } catch (IOException e) {
                                                System.out.println("IO exception");
                                            }
                                        }
                                    }
                            
Le fichier ou le répertoire est supprimé

La méthode deleteIfExists() de la classe Files peut également être utilisée pour supprimer un fichier, mais si le fichier n'existe pas, aucune exception n'est levée.

Attributs de fichier

Vous pouvez utiliser la méthode readAttributes() de la classe Files pour récupérer des informations utiles sur un fichier. La méthode prend deux arguments - un objet Path et BasicFileAttributes.class - et renvoie une instance de la classe BasicFileAttributes. Vous pouvez créer une instance avec une instruction telle que la suivante

                                BasicFileAttributes attr = Files.readAttributes(chemin, BasicFileAttributes.class);
                            

Après avoir créé un objet BasicFileAttributes, vous pouvez utiliser plusieurs méthodes pour extraire des informations sur un fichier. Par exemple, la méthode size() renvoie la taille d'un fichier en octets. Des méthodes telles que creationTime() et lastModifiedTime() renvoient la date de création et modification.

Exemple 5 :
                                    import java.io.IOException;
                                    import java.nio.file.*;
                                    import java.nio.file.attribute.BasicFileAttributes;
                                    
                                    public class Test {
                                        public static void main(String args[]) {
                                            Path chemin = Paths.get("intro.txt");
                                            try {
                                                BasicFileAttributes attr = Files.readAttributes(chemin, BasicFileAttributes.class);
                                                System.out.println("date de création " + attr.creationTime());
                                                System.out.println("date de la dernière modification " + attr.lastModifiedTime());
                                                System.out.println("Taille " + attr.size());
                                    
                                            } catch (IOException e) {
                                                System.out.println("IO Exception");
                                            }
                                        }
                                    }
                            
heure de création 2019-09-14T01:59:48Z
heure de la dernière modification 2019-09-14T02:00:05.295535Z
Taille 16
 Remarque !  Outre BasicFileAttributes, Java prend en charge des classes spécialisées pour les attributs de fichier DOS utilisés sur les systèmes DOS et les attributs de fichier POSIX utilisés sur des systèmes tels que UNIX. Par exemple, les fichiers DOS peuvent être masqués ou en lecture seule et les fichiers UNIX peuvent avoir un propriétaire de groupe.

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :