Création et suppression de répertoires et de fichiers

La classe Files propose des méthodes statiques pour gérer la création et la suppression de répertoires et fichiers. Voici quelques-unes de ces méthodes :

static Path createDirectory(Path dir)
static Path createFile(Path file)
static void delete(Path path)
static void deleteIfExists(Path path)

Ces opérations peuvent lever des exceptions telles que FileAlreadyExistsException, NoSuchFileException ou DirectoryNotEmptyException.

Consultation des attributs de fichiers

Pour interroger les propriétés d'un fichier, la classe Files fournit plusieurs méthodes utiles :

static boolean exists(Path path)
static boolean notExists(Path path)
static boolean isReadable(Path path)
static boolean isWritable(Path path)
static boolean isExecutable(Path path)
static boolean isRegularFile(Path path)
static long size(Path path)
static boolean isDirectory(Path path)
static boolean isHidden(Path path)
static FileTime getLastModifiedTime(Path path)

Copie et déplacement de fichiers et répertoires

La méthode copy() de la classe Files permet de copier des fichiers ou répertoires. Elle accepte des options de copie via l'énumération StandardCopyOption :

static Path copy(Path source, Path target, CopyOption... options)
// Options disponibles : ATOMIC_MOVE, COPY_ATTRIBUTES, REPLACE_EXISTING

Exemple d'utilisation pour copier un fichier en remplaçant l'existante :

Path srcPath = Paths.get("E:\\rapports\\analyse.docx");
Path dstPath = Paths.get("E:\\archives\\copie_analyse.docx");
try {
    Files.copy(srcPath, dstPath, StandardCopyOption.REPLACE_EXISTING);
} catch (NoSuchFileException e) {
    System.err.println("Fichier source introuvable : " + e.getMessage());
} catch (IOException e) {
    System.err.println("Erreur d'E/S : " + e.getMessage());
}

Pour déplacer ou renommer un fichier, utilisez move() :

static Path move(Path source, Path target, CopyOption... options)

Exemple de déplacement d'un fichier vers un autre répertoire :

Path original = Paths.get("C:\\temp\\image.png");
Path destination = Paths.get("C:\\data\\nouveau_dossier\\image.png");
try {
    Files.move(original, destination, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
    e.printStackTrace();
}

Lecture et écriture de petits fichiers

Pour les fichiers de petite taille, Files offre des méthodes pratiques d'écriture. La méthode write() accepte des options via StandardOpenOption :

static Path write(Path path, byte[] bytes, OpenOption... options)
// Options courantes : APPEND, CREATE, CREATE_NEW, DELETE_ON_CLOSE, READ, WRITE, TRUNCATE_EXISTING

Une surcharge permet d'écrire plusieurs lignes de texte :

static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options)

Pour lire le contenu, utilisez :

static byte[] readAllBytes(Path path)
static List<String> readAllLines(Path path, Charset cs)

Création de flux avec la classe Files

La classe Files permet de créer des flux d'entrée et de sortie liés à des fichiers. Pour obtenir un flux d'entrée, utilisez newInputStream() :

static InputStream newInputStream(Path path, OpenOption... options) throws IOException

Exemple de lecture via un flux :

Path fichierSource = Paths.get("src\\donnees.bin");
try (InputStream fluxEntree = Files.newInputStream(fichierSource, StandardOpenOption.READ)) {
    // Traitement du flux d'entrée
} catch (IOException e) {
    System.err.println("Erreur lors de la lecture : " + e.getMessage());
}

Pour l'écriture, newOutputStream() génère un flux de sortie :

static OutputStream newOutputStream(Path path, OpenOption... options) throws IOException

Exemple avec un flux tamponné pour l'écriture :

Path fichierDestination = Paths.get("src\\resultats.log");
try (OutputStream fluxSortie = Files.newOutputStream(fichierDestination,
        StandardOpenOption.CREATE, StandardOpenOption.APPEND);
     BufferedOutputStream fluxTampon = new BufferedOutputStream(fluxSortie)) {
    // Écriture de données via le flux tamponné
} catch (IOException e) {
    System.err.println("Erreur d'écriture : " + e.getMessage());
}

Des méthodes supplémentaires permettent de créer des lecteurs et rédacteurs tamponnés :

static BufferedReader newBufferedReader(Path path, Charset charset)
static BufferedWriter newBufferedWriter(Path path, Charset charset, OpenOption... options)