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.*;
                            

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.

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

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));
                                        }
                                    }
                            

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());
                                        }
                                    }
                            

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é");
                                            }
                                        }
                                    }
                            

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");
                                            }
                                        }
                                    }
                            

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.

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");
                                            }
                                        }
                                    }