Fichiers Java – Classe java.nio.file.Files

Tutoriels
Java

La classe Java Files a été introduite dans Java 1.7 et fait partie du package java.nio.file.

Classe Java Files

  • La classe Java Files contient des méthodes statiques qui fonctionnent sur les fichiers et répertoires.
  • Cette classe est utilisée pour des opérations de fichiers de base telles que la création, la lecture, l’écriture, la copie et la suppression des fichiers ou répertoires du système de fichiers.

Avant de continuer, jetons d’abord un coup d’œil aux termes ci-dessous :

  1. Chemin : Il s’agit de l’interface qui remplace la classe java.io.File en tant que représentation d’un fichier ou d’un répertoire lorsque nous travaillons avec Java NIO.
  2. Chemins : Cette classe contient une méthode statique pour créer une instance de Chemin.

L’interface java.nio.file.Path est similaire à l’ancienne classe java.io.File. Path représente l’emplacement du fichier et lorsque nous créons un chemin vers un nouveau fichier, il ne crée pas le fichier réel avant que nous le créions en utilisant Files.createFile(Path filePath). Comme nous pouvons le voir dans le diagramme ci-dessus, la classe Paths est utilisée pour créer une instance de Path et la classe Files utilise une instance de Path pour travailler sur un fichier. Les objets File et Path savent comment se convertir l’un en l’autre, c’est ainsi que nous pouvons utiliser du code plus ancien pour interagir avec la nouvelle utilité Files.

Java IO vs NIO

Comment créer un chemin

Nous pouvons créer un objet Path en appelant la méthode Paths.get(String first, String... more) de la classe Paths.

Path path1 = Paths.get("/tmp/file.txt"); // For UNIX

Path path2 = Paths.get("D:/data/file.txt"); // For Windows

Nous pouvons également créer un objet Path en séparant les parties du chemin dans la méthode Paths.get().

Path path1 = Paths.get("/tmp", "file.txt");

Path path2 = Paths.get("D:", "data", "file.txt");

Path path3 = Paths.get("D:/data", "file.txt") ;

Comme nous pouvons le voir, nous pouvons passer le nom du dossier et du fichier séparément dans la méthode Paths.get().

Méthodes de fichiers Java

La classe Java NIO Files contient des méthodes statiques qui sont utilisées pour manipuler des fichiers et des répertoires et ces méthodes fonctionnent principalement sur l’objet Path. Examinons ci-dessous les méthodes de la classe Files:

  1. copie(InputStream in, Chemin cible, Option de copie… options): Cette méthode copie tous les octets du flux d’entrée spécifié vers le fichier cible spécifié et elle retourne le nombre d’octets lus ou écrits sous forme de valeur longue.
  2. copie(Chemin source, OutputStream out): Cette méthode copie tous les octets du fichier source spécifié vers le flux de sortie donné et elle retourne le nombre d’octets lus ou écrits sous forme de valeur longue.
  3. copie(Chemin source, Chemin cible, Option de copie… options): Cette méthode copie le fichier source donné vers le fichier cible spécifié et elle retourne le chemin du fichier cible.
  4. créerRépertoires(Chemin dir, FileAttribute<?>… attrs): Cette méthode crée des répertoires en utilisant le chemin donné en créant d’abord tous les répertoires parents qui n’existent pas encore. Cette méthode ne lancera pas d’exception si le répertoire ne peut pas être créé car il existe déjà. FileAttribute est un paramètre facultatif pour définir automatiquement lors de la création des répertoires inexistants et elle retourne le chemin du répertoire créé.
  5. createDirectory(Path dir, FileAttribute<?>… attrs): Cette méthode crée un répertoire en utilisant le chemin donné. Si le répertoire est créé avec succès, elle renverra le chemin du répertoire créé. Si le répertoire existe déjà, une nio.file.FileAlreadyExistsException sera levée.
  6. createFile(Path path, FileAttribute<?>… attrs): Cette méthode crée un nouveau fichier vide en utilisant le chemin donné et renvoie le chemin du fichier nouvellement créé s’il est créé avec succès. Si le fichier existe déjà, une nio.file.FileAlreadyExistsException sera levée.
  7. createTempDirectory(Path dir, String prefix, FileAttribute<?>… attrs): Cette méthode crée un répertoire temporaire en utilisant le chemin donné et génère le nom du répertoire en utilisant le préfixe donné. Elle renverra le chemin du répertoire temporaire nouvellement créé.
  8. createTempDirectory(String prefix, FileAttribute<?>… attrs): Cette méthode crée un répertoire temporaire dans le répertoire de fichiers temporaires par défaut et génère le nom du répertoire en utilisant le préfixe donné. Elle renverra le chemin du répertoire temporaire nouvellement créé, qui est associé au système de fichiers par défaut.
  9. createTempFile(Path dir, String prefix, String suffix, FileAttribute<?>… attrs): Cette méthode crée un fichier temporaire dans le répertoire spécifié et génère le nom de fichier en utilisant le préfixe et le suffixe donnés, puis renvoie le chemin du fichier nouvellement créé.
  10. createTempFile(String préfixe, String suffixe, FileAttribute<?>… attrs): Cette méthode crée un fichier temporaire dans le répertoire temporaire par défaut et génère le nom de fichier en utilisant le préfixe et le suffixe donnés, puis renvoie le chemin du fichier nouvellement créé.
  11. delete(Chemin chemin): Il s’agit d’une méthode void qui supprime simplement le fichier du chemin spécifié. Cette méthode lance NoSuchFileException si le fichier n’existe pas au chemin spécifié et si le fichier est un répertoire et qu’il n’est peut-être pas vide et ne peut pas être supprimé, dans ce cas, il lancera
  12. deleteIfExists(Chemin chemin): Cette méthode vérifie si le fichier existe avant de le supprimer et renvoie la valeur booléenne true si le fichier au chemin donné est supprimé avec succès et renvoie false si le fichier n’existe pas au chemin donné. Si le fichier est un répertoire et qu’il n’est peut-être pas vide et ne peut pas être supprimé, dans ce cas, il lancera
  13. exists(Chemin chemin): Cette méthode vérifie si le fichier existe au chemin spécifié et si le fichier existe, elle renverra true, sinon elle renverra false.
  14. getLastModifiedTime(Chemin chemin, Linkoption… options): Cette méthode renvoie l’heure de dernière modification d’un fichier à partir du chemin donné en tant que
  15. getOwner(Chemin chemin, Linkoption… options): Cette méthode renvoie UserPrincipal représentant le propriétaire du fichier au chemin donné.
  16. isDirectory(Path path, Linkoption… options): Cette méthode vérifie si le fichier est un répertoire à partir du chemin donné. Elle retourne vrai si le fichier est un répertoire et faux si le fichier n’existe pas ou n’est pas un répertoire, ou s’il est impossible de déterminer si le fichier est un répertoire ou non.
  17. isExecutable(Path path): Cette méthode vérifie si le fichier au chemin donné est exécutable ou non, et elle vérifie également si le fichier existe et si cette JVM a le privilège approprié pour exécuter le fichier. Elle retourne vrai si le fichier existe au chemin donné et est exécutable, et faux si le fichier n’existe pas ou si la JVM n’a pas suffisamment de privilèges pour exécuter le fichier ou si l’accès ne peut pas être déterminé.
  18. isHidden(Path path): Cette méthode indique si le fichier au chemin donné est considéré comme caché ou non. La définition exacte de caché dépend du système d’exploitation ou du fournisseur. Dans le cas d’un système UNIX, un fichier est considéré comme caché si le nom du fichier commence par un caractère point (‘.’). Dans le cas de WINDOWS, un fichier est considéré comme caché s’il n’est pas un répertoire et si l’attribut de fichier caché DOS est défini. Elle retourne vrai si le fichier au chemin donné est considéré comme caché, sinon faux.
  19. isReadable(Path path): Cette méthode teste si le fichier au chemin donné est lisible ou non. Elle retourne vrai si le fichier au chemin spécifié existe et est lisible, et faux si le fichier n’existe pas ou si l’accès en lecture est refusé parce que la JVM n’a pas suffisamment de privilèges ou si l’accès ne peut pas être déterminé.
  20. isWritable(Chemin chemin): Cette méthode teste si le fichier au chemin donné est inscriptible ou non. Elle renvoie vrai si le fichier au chemin spécifié existe et est inscriptible, et faux si le fichier n’existe pas ou si l’accès en écriture est refusé parce que la JVM n’a pas les privilèges suffisants ou que l’accès ne peut pas être déterminé.
  21. move(Chemin source, Chemin cible, OptionCopie… options): Cette méthode déplace ou renomme un fichier source vers un fichier cible et renvoie le chemin du fichier cible. Le paramètre d’option peut inclure ce qui suit : REPLACE_EXISTING: Cela signifie que si le fichier cible existe, le remplace s’il n’est pas un répertoire non vide. ATOMIC_MOVE: Cela signifie que le déplacement est effectué en tant qu’opération atomique du système de fichiers et que toutes les autres options sont ignorées. Cette méthode lève une FileAleadyExistsException si le fichier cible existe mais ne peut pas être remplacé parce que l’option REPLACE_EXISTING n’est pas spécifiée. Cette méthode lève une DirectoryNotEmptyException si l’option REPLACE_EXISTING est spécifiée mais que le fichier ne peut pas être remplacé car c’est un répertoire non vide.
  22. newBufferedReader(Chemin chemin, JeuDeCaractères cs): Cette méthode ouvre un fichier en utilisant le chemin donné pour la lecture en renvoyant un BufferedReader qui est utilisé pour lire du texte à partir du fichier. Les octets du fichier sont décodés en caractères en utilisant le jeu de caractères spécifié.
  23. newBufferedWriter(Path path, Charset cs, Openoption… options): Cette méthode ouvre ou crée un fichier en utilisant le chemin donné pour l’écriture en retournant BufferedWriter qui est utilisé pour écrire du texte dans le fichier. Le paramètre options spécifie comment le fichier est créé ou ouvert. Si aucune option n’est spécifiée, alors les options CREATE, TRUNCATE_EXISTING et WRITE sont considérées par défaut, cela signifie qu’il ouvre le fichier pour l’écriture et le crée s’il n’existe pas ou tronque le fichier existant à une taille de 0 s’il existe. Cette méthode lance UnsupportedOperationException si une option non prise en charge est spécifiée.
  24. newByteChannel(Path path, OpenOption… options): Cette méthode crée ou ouvre le fichier en utilisant le chemin spécifié en retournant un canal de byte pouvant être recherché pour accéder au fichier. Cette méthode lance UnsupportedOperationException si une option non prise en charge est spécifiée.
  25. newDirectoryStream(Path path): Cette méthode ouvre un répertoire en retournant un DirectoryStream pour itérer sur toutes les entrées du répertoire à partir du chemin spécifié. Les éléments retournés par l’itérateur de DirectoryStream sont de type Path et chacun représente une entrée dans le répertoire. Cette méthode lance NotDirectoryException si le fichier au chemin donné ne peut pas être ouvert car il n’est pas un répertoire.
  26. newDirectoryStream(Path path, Filter<? super Path > filter): Cette méthode ouvre un répertoire en renvoyant un DirectoryStream pour itérer sur toutes les entrées du répertoire depuis le chemin spécifié. Les éléments retournés par l’itérateur de DirectoryStream sont de type Path et chacun représente une entrée dans le répertoire, ces entrées sont filtrées par le filtre spécifié. Cette méthode lance NotDirectoryException si le fichier au chemin donné ne peut pas être ouvert car ce n’est pas un répertoire.
  27. newDirectoryStream(Path path, String glob): Cette méthode ouvre un répertoire en renvoyant un DirectoryStream pour itérer sur toutes les entrées du répertoire depuis le chemin spécifié. Les éléments retournés par l’itérateur de DirectoryStream sont de type Path et chacun représente une entrée dans le répertoire, ces entrées sont filtrées en faisant correspondre la représentation String de leurs noms de fichier avec le modèle glob spécifié. Cette méthode lance NotDirectoryException si le fichier au chemin donné ne peut pas être ouvert car ce n’est pas un répertoire et PatternSyntaxException si le motif est invalide.
  28. newInputStream(Path path, Openoption… options): Cette méthode ouvre un fichier en renvoyant un flux d’entrée pour lire le fichier depuis le chemin spécifié. Le paramètre options détermine comment le fichier est ouvert et s’il n’y a pas d’options spécifiées, alors il ouvre le fichier avec READ Cette méthode lance IllegalArgumentException si une combinaison invalide d’options est spécifiée et UnsupportedOperationException si une option non prise en charge est spécifiée.
  29. newOutputStream(Chemin chemin, Openoption… options): Cette méthode ouvre un fichier en renvoyant un flux de sortie pour écrire des octets dans le fichier au chemin spécifié. Le paramètre options détermine comment le fichier est ouvert et si aucune option n’est spécifiée, alors il considère les options CREATE, TRUNCATE_EXISTING et WRITE par défaut, ce qui signifie qu’il ouvre le fichier pour l’écriture et le crée s’il n’existe pas ou tronque le fichier existant à la taille de 0 s’il existe. Cette méthode lance une IllegalArgumentException si une combinaison invalide d’options est spécifiée et une UnsupportedOperationException si une option non prise en charge est spécifiée.
  30. notExists(Chemin chemin, LinkOption options): Cette méthode teste si le fichier au chemin spécifié n’existe pas. Le paramètre options est utilisé pour indiquer comment les liens symboliques sont gérés si le fichier est un lien symbolique. Par défaut, les liens symboliques sont suivis. Si l’option NOFOLLOW_LINK est présente, alors les liens symboliques ne sont pas suivis. Cette méthode renvoie vrai si le fichier n’existe pas au chemin spécifié et faux si le fichier existe ou si son existence ne peut pas être déterminée.
  31. readAllBytes(Chemin chemin): Cette méthode lit tous les octets du fichier au chemin donné et renvoie le tableau d’octets contenant les octets lus à partir du fichier.
  32. readAllLines(Chemin chemin, Charset cs): Cette méthode lit toutes les lignes du fichier au chemin donné et renvoie la Liste contenant les lignes du fichier.
  33. size(Chemin chemin): Cette méthode retourne la taille du fichier au chemin spécifié en octets.
  34. walkFileTree(Chemin départ, FileVisitor<? Super Chemin> visiteur): Cette méthode est utilisée pour parcourir le répertoire. Elle parcourt le répertoire au chemin spécifié de manière récursive et retourne le fichier de départ.
  35. write(Chemin chemin, byte[] octets, OpenOption… options): Cette méthode écrit des octets dans un fichier au chemin spécifié. Le paramètre options spécifie comment le fichier est créé ou ouvert. Si aucune option n’est spécifiée, elle considère par défaut les options CREATE, TRUNCATE_EXISTING et WRITE, ce qui signifie qu’elle ouvre le fichier en écriture et le crée s’il n’existe pas ou tronque le fichier existant à une taille de 0 s’il existe. Tous les octets du tableau d’octets sont écrits dans le fichier. Cette méthode garantit que le fichier est fermé lorsque tous les octets ont été écrits et retourne le chemin du fichier écrit.

Créer un fichier en utilisant la classe Files

La classe Files fournit la méthode createFile(Chemin cheminFichier, FileAttribute<?>… attributs) pour créer un fichier en utilisant le chemin spécifié. Jetons un coup d’œil au programme d’exemple ci-dessous.

package com.journaldev.examples;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * Java Create file using Files class
 * 
 * @author pankaj
 *
 */
public class FilesCreateFileExample {

	public static void main(String[] args) {
		
		//initialiser l'objet Chemin
		Path path = Paths.get("D:/data/file.txt");
		//créer le fichier
		try {
			Path createdFilePath = Files.createFile(path);
			System.out.println("File Created at Path : "+createdFilePath);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

La sortie du programme ci-dessus est la suivante :

File Created at Path : D:\data\file.txt

Créer des répertoires à l’aide de la classe Files

La classe Files fournit les méthodes createDirectory(Path dir, FileAttribute<?>… attrs) et createDirectories(Path dir, FileAttribute<?>… attrs) pour créer des répertoires simples et multiniveaux en utilisant le Path spécifié. Jetons un coup d’œil au programme d’exemple ci-dessous.

package com.journaldev.examples;

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

/**
 * Java Create directories using Files class
 * 
 * @author pankaj
 *
 */
public class FilesCreateDirectoriesExample {

	public static void main(String[] args) {
		// Initialiser les objets Path
		Path path1 = Paths.get("D:/pankaj");
		Path path2 = Paths.get("D:/pankaj/java7");
		Path path3 = Paths.get("D:/pankaj/java7/Files");
		
		try {
			Path createdDir1 = Files.createDirectory(path1);//first level directory
			Path createdDir2 = Files.createDirectory(path2);//second level directory
			Path createdDir3 = Files.createDirectory(path3);//all level directories
			System.out.println("First Level Directory Created at Path : "+createdDir1);
			System.out.println("Second Level Directory Created at Path : "+createdDir2);
			System.out.println("All Level Directories Created at Path : "+createdDir3);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

La sortie du programme ci-dessus est la suivante:

First Level Directory Created at Path : D:\pankaj
Second Level Directory Created at Path : D:\pankaj\java7
All Level Directories Created at Path : D:\pankaj\java7\Files

Convertir un fichier en chemin et vice versa

Les objets Fichier et Chemin peuvent être convertis l’un en l’autre en utilisant les méthodes suivantes:

File file = new File(“D:/data/file.txt”);

Path path = file.toPath();

File file1 = path.toFile();

Lire les données du fichier à l’aide de la classe Files

La classe Files fournit les méthodes suivantes pour lire un fichier.

  1. readAllBytes(Path path): Cette méthode lit tous les octets du fichier au chemin donné et renvoie le tableau d’octets contenant les octets lus à partir du fichier.
  2. readAllLines(Path path,Charsetcs): Cette méthode lit toutes les lignes du fichier au chemin donné et retourne la Liste contenant les lignes du fichier.

Jetons un coup d’œil au programme d’exemple ci-dessous.

package com.journaldev.examples;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

/**
 * Java Files read file example
 * 
 * @author pankaj
 *
 */
public class FilesReadFileExample {

	public static void main(String[] args) {
		
		Path path = Paths.get("D:/data/file.txt");
		try {
			byte[] bs = Files.readAllBytes(path);
			List<String> strings = Files.readAllLines(path);
			
			System.out.println("Read bytes: \n"+new String(bs));
			System.out.println("Read lines: \n"+strings);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

La sortie du programme ci-dessus est la suivante:

Read bytes: 
Hello world
This is Read file example
Thank you
Read lines: 
[Hello world, This is Read file example, Thank you]

Copier un fichier en utilisant la classe Files

La classe Files fournit la méthode copy(Path source, Path target, CopyOption… options) qui copie le fichier source donné dans le fichier cible spécifié et retourne le chemin du fichier cible. Jetons un coup d’œil au programme d’exemple ci-dessous:

package com.journaldev.examples;

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

/**
 * Java Files copy file example
 * 
 * @author pankaj
 *
 */
public class FilesCopyFileExample {

	public static void main(String[] args) {
		Path sourcePath = Paths.get("D:/data/sourceFile.txt");
		Path targetPath = Paths.get("D:/data/targetFile.txt");
		
		try {
			Path path = Files.copy(sourcePath, targetPath,StandardCopyOption.REPLACE_EXISTING);//copy with REPLACE_EXISTING option
			System.out.println("Target file Path : "+path);
			System.out.println("Copied Content : \n"+new String(Files.readAllBytes(path)));
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

La sortie du programme ci-dessus est la suivante:

Target file Path : D:\data\targetFile.txt
Copied Content : 
Hello world
This is Copy file example
Thank you

Déplacer un fichier en utilisant la classe Files

La classe Java Files fournit la méthode move(Path source, Path target, CopyOption… options) qui déplace ou renomme un fichier source vers un fichier cible et renvoie le chemin du fichier cible. Le paramètre Option peut inclure ce qui suit : REPLACE_EXISTING: Cela signifie que si le fichier cible existe, il est remplacé s’il ne s’agit pas d’un répertoire non vide. ATOMIC_MOVE: Cela signifie que le déplacement est effectué en tant qu’opération atomique du système de fichiers et que toutes les autres options sont ignorées. Cette méthode lance FileAleadyExistsException si le fichier cible existe mais ne peut pas être remplacé car l’option REPLACE_EXISTING n’est pas spécifiée. Cette méthode lance DirectoryNotEmptyException si l’option REPlACE_EXISTING est spécifiée mais que le fichier ne peut pas être remplacé car il s’agit d’un répertoire non vide. Jetons un coup d’œil au programme d’exemple ci-dessous :

package com.journaldev.examples;

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

/**
 * Java Files move file example
 * 
 * @author pankaj
 *
 */
public class FilesMoveFileExample {

	public static void main(String[] args) {
		Path sourcePath = Paths.get("D:/data/sourceFile.txt");
		Path targetPath = Paths.get("D:/data/targetFile.txt");
		try {
			Path path = Files.move(sourcePath, targetPath,StandardCopyOption.REPLACE_EXISTING);//move with REPLACE_EXISTING option
			System.out.println("Target file Path : "+path);
			System.out.println("Moved Content : \n"+new String(Files.readAllBytes(path)));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

Écrire un fichier à l’aide de la classe Files

La classe Files de Java NIO offre la méthode write(Path path, byte[] bytes, OpenOption... options), qui écrit des octets dans un fichier situé au chemin spécifié. Le paramètre options précise comment le fichier est créé ou ouvert. En l’absence d’options spécifiées, il considère CREATE, TRUNCATE_EXISTING et WRITE par défaut. Cela signifie qu’il ouvre le fichier en écriture, le crée s’il n’existe pas, ou tronque le fichier existant à une taille de 0 s’il existe. Tous les octets du tableau d’octets sont écrits dans le fichier. Cette méthode garantit que le fichier est fermé une fois tous les octets écrits et renvoie le chemin du fichier écrit.

package com.journaldev.examples;

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

/**
 * Java Files write file example
 * 
 * @author pankaj
 *
 */
public class FilesWriteFileExample {

	public static void main(String[] args) {
		Path path = Paths.get("D:/data/test.txt");
		try {
			String str = "This is write file Example";
			byte[] bs = str.getBytes();
			Path writtenFilePath = Files.write(path, bs);
			System.out.println("Written content in file:\n"+ new String(Files.readAllBytes(writtenFilePath)));
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

Parcourir l’arborescence des fichiers

La classe Files propose la méthode walkFileTree(Path start, FileVisitor visitor), utilisée pour parcourir le répertoire. Elle traverse récursivement le répertoire au chemin spécifié et renvoie le fichier de départ.

package com.journaldev.examples;

import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;

/**
 * Java Files walk file tree example
 * 
 * @author pankaj
 *
 */
public class FilesWalkFileTreeExample {

	public static void main(String[] args) {
		Path path = Paths.get("D:/pankaj");
		try {
			Files.walkFileTree(path, new FileVisitor<Path>() {

				@Override
				public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
					System.out.println("Post Visit Directory: "+dir);
					return FileVisitResult.CONTINUE;
				}

				@Override
				public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
					System.out.println("Pre Visit Directory: "+dir);
					return FileVisitResult.CONTINUE;
				}

				@Override
				public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
					System.out.println("Visit File: "+file);
					return FileVisitResult.CONTINUE;
				}

				@Override
				public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
					System.out.println("Visit Failed File: "+file);
					return FileVisitResult.CONTINUE;
				}
			});
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

La sortie du programme ci-dessus est la suivante :

Pre Visit Directory: D:\pankaj
Pre Visit Directory: D:\pankaj\java6
Pre Visit Directory: D:\pankaj\java6\Files
Visit File: D:\pankaj\java6\Files\file.txt.txt
Post Visit Directory: D:\pankaj\java6\Files
Post Visit Directory: D:\pankaj\java6
Pre Visit Directory: D:\pankaj\java7
Pre Visit Directory: D:\pankaj\java7\Files
Visit File: D:\pankaj\java7\Files\file.txt.txt
Post Visit Directory: D:\pankaj\java7\Files
Post Visit Directory: D:\pankaj\java7
Pre Visit Directory: D:\pankaj\java8
Pre Visit Directory: D:\pankaj\java8\Files
Visit File: D:\pankaj\java8\Files\file.txt.txt
Post Visit Directory: D:\pankaj\java8\Files
Post Visit Directory: D:\pankaj\java8
Post Visit Directory: D:\pankaj

Remarquez que tous les fichiers et dossiers sont traités de manière récursive. Cela est très utile lorsque vous souhaitez effectuer un traitement commun sur tous les fichiers, par exemple, renommer tous les fichiers dans un répertoire de manière récursive. C’est tout pour la classe Files de Java. Référence : Documentation API

Source:
https://www.digitalocean.com/community/tutorials/java-files-nio-files-class