Classes File, Path, Files : vue d’ensemble, création d’objets

1. Classe File : comment tout a commencé

Même si nous avons établi qu’il vaut mieux ne pas utiliser la classe File dans les nouveaux projets, il existe de nombreux systèmes legacy où elle est employée. Il est donc important de la comprendre et de savoir la manipuler. La classe File est une ancienne façon de représenter un fichier ou un répertoire sur le disque. Mais ne confondez pas : un objet File n’est pas le fichier lui‑même, mais seulement un « pointeur »/passeport de chemin. Par exemple, l’expression File f = new File("hello.txt"); ne crée pas de fichier sur le disque — vous avez simplement décrit un chemin.

Comment créer un objet File ?

import java.io.File;

public class FileDemo {
    public static void main(String[] args) {
        File file = new File("example.txt"); // chemin relatif
        File folder = new File("mydir");     // répertoire

        System.out.println("Chemin absolu: " + file.getAbsolutePath());
        System.out.println("Le fichier existe-t-il ? " + file.exists());
        System.out.println("Est-ce un fichier ? " + file.isFile());
        System.out.println("Est-ce un répertoire ? " + folder.isDirectory());
    }
}

À retenir :
La création d’un objet File ne crée pas le fichier sur le disque. C’est juste un « raccourci ». Pour que le fichier apparaisse réellement, il faut initier explicitement sa création (par exemple, écrire des données ou appeler file.createNewFile()).

Méthodes principales de la classe File

• exists() — vérifie si le fichier/le répertoire existe.
• isFile() — est‑ce un fichier (et non un dossier) ?
• isDirectory() — est‑ce un répertoire ?
• getAbsolutePath() — obtenir le chemin absolu.
• length() — taille du fichier en octets.
• getName() — nom du fichier ou du dossier.
• delete() — supprimer le fichier/le répertoire (s’il est vide).

Exemple : afficher des informations sur un fichier

File file = new File("example.txt");
System.out.println("Nom: " + file.getName());
System.out.println("Chemin: " + file.getAbsolutePath());
System.out.println("Taille: " + file.length() + " octets");
System.out.println("Existe ? " + file.exists());

2. Classe Path : regard moderne sur les fichiers

Path fait partie de la nouvelle API de fichiers (NIO.2, depuis Java 7). C’est une abstraction de chemin vers un fichier/répertoire, et le chemin peut se trouver non seulement sur le disque local, mais aussi, par exemple, dans une archive ZIP ou sur une ressource distante (si un fournisseur approprié est présent).

Si File est une vieille carte papier, alors Path est un GPS.

Comment créer un objet Path ?

import java.nio.file.Path;
import java.nio.file.Paths;

public class PathDemo {
    public static void main(String[] args) {
        Path path1 = Paths.get("example.txt"); // chemin relatif
        Path path2 = Paths.get("folder", "file.txt"); // on assemble des parties de chemin

        System.out.println("Chemin 1: " + path1.toAbsolutePath());
        System.out.println("Chemin 2: " + path2.toAbsolutePath());
    }
}

Atout : pas besoin de penser aux séparateurs. Paths.get choisira le format correct pour votre OS.

Conversion entre File et Path

• File → Path : file.toPath()
• Path → File : path.toFile()

File file = new File("test.txt");
Path path = file.toPath();

Path anotherPath = Paths.get("data.txt");
File anotherFile = anotherPath.toFile();

Travail avec les chemins : resolve, relativize, normalize

Concaténation des chemins (resolve)

Path dir = Paths.get("myfolder");
Path file = dir.resolve("notes.txt"); // myfolder/notes.txt
System.out.println(file); // myfolder/notes.txt

Chemin relatif (relativize)

Path pathA = Paths.get("folderA/file1.txt");
Path pathB = Paths.get("folderA/subfolder/file2.txt");
Path relative = pathA.relativize(pathB);
System.out.println(relative); // ../subfolder/file2.txt

Normalisation du chemin (normalize)

Path messy = Paths.get("folder/../folder/file.txt");
Path clean = messy.normalize();
System.out.println(clean); // folder/file.txt

Exemple : construire un chemin vers un fichier

Path home = Paths.get(System.getProperty("user.home"));
Path docs = home.resolve("Documents");
Path myFile = docs.resolve("myfile.txt");
System.out.println("Chemin vers le fichier: " + myFile.toAbsolutePath());

3. Classe Files : votre couteau suisse

La classe Files du package java.nio.file est un ensemble utilitaire de méthodes statiques pour travailler avec les fichiers et répertoires au‑dessus de Path. Elle sait pratiquement tout faire : vérifier l’existence, créer/supprimer, lire/écrire, copier/déplacer, obtenir des attributs et parcourir un arbre de répertoires.

Méthodes principales de la classe Files

• Files.exists(path) — vérifie si le fichier/le répertoire existe.
• Files.isDirectory(path) — est‑ce un répertoire ?
• Files.size(path) — taille du fichier.
• Files.createFile(path) — créer un fichier.
• Files.createDirectory(path) — créer un répertoire.
• Files.delete(path) — supprimer un fichier/un répertoire.
• Files.copy(src, dest) — copier un fichier.
• Files.move(src, dest) — déplacer/renommer.
• Files.getLastModifiedTime(path) — date de dernière modification.
• Files.readAllBytes(path) — lire tout le fichier dans un tableau d’octets.
• Files.readAllLines(path) — lire toutes les lignes d’un fichier texte.
• Files.write(path, bytes) — écrire des octets dans un fichier.

Exemple : vérifier un fichier

import java.nio.file.*;

public class FilesDemo {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");

        System.out.println("Le fichier existe ? " + Files.exists(path));
        System.out.println("Est-ce un répertoire ? " + Files.isDirectory(path));

        if (Files.exists(path)) {
            try {
                System.out.println("Taille du fichier: " + Files.size(path) + " octets");
            } catch (Exception e) {
                System.out.println("Erreur lors de la récupération de la taille: " + e.getMessage());
            }
        }
    }
}

4. Pratique : créer des objets, afficher des propriétés

Créer des objets pour un fichier et un répertoire

import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;

public class CompareDemo {
    public static void main(String[] args) {
        // Ancienne approche
        File oldFile = new File("test.txt");
        File oldDir = new File("mydir");

        // Nouvelle approche
        Path newFile = Paths.get("test.txt");
        Path newDir = Paths.get("mydir");

        System.out.println("=== File API ===");
        System.out.println("Fichier: " + oldFile.getAbsolutePath());
        System.out.println("Existe ? " + oldFile.exists());
        System.out.println("Est-ce un fichier ? " + oldFile.isFile());
        System.out.println("Est-ce un répertoire ? " + oldDir.isDirectory());

        System.out.println("\n=== Path API ===");
        System.out.println("Fichier: " + newFile.toAbsolutePath());
        System.out.println("Existe ? " + java.nio.file.Files.exists(newFile));
        System.out.println("Est-ce un fichier ? " + java.nio.file.Files.isRegularFile(newFile));
        System.out.println("Est-ce un répertoire ? " + java.nio.file.Files.isDirectory(newDir));
    }
}

Afficher les propriétés du fichier

import java.nio.file.*;

public class FileProperties {
    public static void main(String[] args) {
        Path path = Paths.get("test.txt");

        System.out.println("Chemin absolu: " + path.toAbsolutePath());
        System.out.println("Nom du fichier: " + path.getFileName());
        System.out.println("Dossier parent: " + path.getParent());

        if (Files.exists(path)) {
            try {
                System.out.println("Taille: " + Files.size(path) + " octets");
                System.out.println("Dernière modification: " + Files.getLastModifiedTime(path));
            } catch (Exception e) {
                System.out.println("Erreur lors de la récupération des informations: " + e.getMessage());
            }
        } else {
            System.out.println("Fichier introuvable.");
        }
    }
}

5. Comparaison : File vs Path/Files

En bref : quand utiliser quoi ?

• Pour les nouveaux projets — utilisez Path et Files.
• Pour la maintenance d’un ancien code — il faudra parfois travailler avec File.

6. Nuances utiles

Chemins relatifs et absolus

Un chemin relatif est un chemin par rapport au répertoire de travail courant ; un chemin absolu est le chemin complet depuis la racine du système de fichiers.

Path relative = Paths.get("data", "file.txt");
Path absolute = relative.toAbsolutePath();
System.out.println("Chemin absolu: " + absolute);

Multiplateforme

Path et Files tiennent compte des particularités de l’OS (séparateurs, encodages, etc.). N’écrivez pas manuellement des chemins du type "C:\\folder\\file.txt" — utilisez Paths.get et resolve.

Conversion entre File et Path

Si vous avez un ancien code basé sur File, il est facile de passer à la nouvelle API :

File legacy = new File("legacy.txt");
Path modern = legacy.toPath();
if (Files.exists(modern)) {
    // Vous pouvez maintenant utiliser toutes les possibilités de NIO.2
}

Vérifier l’existence d’un fichier

Path path = Paths.get("notes.txt");
if (Files.exists(path)) {
    System.out.println("Fichier trouvé !");
} else {
    System.out.println("Le fichier n'existe pas.");
}

7. Mini‑pratique : créer et vérifier un fichier et un répertoire

import java.nio.file.*;

public class MiniPractice {
    public static void main(String[] args) throws Exception {
        Path dir = Paths.get("demo_dir");
        Path file = dir.resolve("hello.txt");

        // Créer le répertoire s'il n'existe pas
        if (!Files.exists(dir)) {
            Files.createDirectory(dir);
            System.out.println("Répertoire créé: " + dir.toAbsolutePath());
        }

        // Créer le fichier s'il n'existe pas
        if (!Files.exists(file)) {
            Files.createFile(file);
            System.out.println("Fichier créé: " + file.toAbsolutePath());
        }

        // Afficher les propriétés
        System.out.println("Le fichier existe ? " + Files.exists(file));
        System.out.println("Est-ce un fichier ? " + Files.isRegularFile(file));
        System.out.println("Taille: " + Files.size(file) + " octets");

        // Supprimer le fichier et le répertoire (optionnel)
        Files.delete(file);
        Files.delete(dir);
        System.out.println("Fichier et répertoire supprimés.");
    }
}

8. Erreurs typiques lors de l’utilisation de File/Path/Files

Erreur n° 1 : Confusion entre File et Path. Beaucoup de débutants essaient d’utiliser les méthodes de Files avec un objet File. Rappelez‑vous : Files.* travaille avec Path. Si vous avez un File, faites d’abord file.toPath().

Erreur n° 2 : S’attendre à ce que la création d’un objet File ou Path crée le fichier. Un objet chemin est un raccourci, pas un fichier réel. Pour créer, utilisez Files.createFile(path) ou écrivez des données.

Erreur n° 3 : Construire les chemins à la main via une chaîne. N’écrivez pas "folder/file.txt" ou "folder\\file.txt". Utilisez Paths.get(...) et resolve(...). C’est plus sûr et multiplateforme.

Erreur n° 4 : Ignorer les exceptions. Les opérations sur les fichiers lèvent IOException et d’autres exceptions. Gérez‑les avec try-catch ou propagez‑les (throws).

Erreur n° 5 : Vérifier via File.exists(), puis travailler avec Path. Essayez de rester cohérent : si vous avez commencé avec Path, utilisez Files.exists(path) et les autres méthodes de Files.