1. Création de fichiers temporaires : Files.createTempFile
Les fichiers temporaires servent à stocker des données intermédiaires, du cache ou tout résultat qui n’est pas destiné à une conservation longue. En règle générale, ils vivent aussi longtemps que le programme s’exécute ou jusqu’à ce que le besoin de ces données disparaisse.
Le plus souvent, on utilise des fichiers temporaires lors du téléchargement de gros documents (on les charge d’abord dans un dossier temporaire, puis on les déplace à l’emplacement voulu), pour mettre en cache des informations que l’on peut recalculer ou récupérer à nouveau, pour stocker des résultats intermédiaires lors du traitement de grands volumes de données, ainsi que pour l’échange de données entre des parties du programme ou des threads. Un autre scénario courant — les tests : il est plus pratique d’écrire dans des fichiers temporaires que d’encombrer les répertoires de travail.
On peut dire que les fichiers temporaires sont des brouillons pour le programme. Ils ne sont pas destinés au public, mais sans eux le travail n’est pas toujours possible.
En Java, créer un tel fichier est très simple — littéralement en une seule ligne. Pour cela, il existe la méthode Files.createTempFile.
Exemple simple
import java.nio.file.*;
public class TempFileExample {
public static void main(String[] args) throws Exception {
// Crée un fichier temporaire avec le préfixe "myapp_" et le suffixe ".tmp"
Path tempFile = Files.createTempFile("myapp_", ".tmp");
System.out.println("Fichier temporaire créé : " + tempFile);
// On peut y écrire des données
Files.writeString(tempFile, "Ce sont des données temporaires");
// On relit
String data = Files.readString(tempFile);
System.out.println("Contenu : " + data);
}
}
Que se passe-t-il ?
- Le fichier est créé dans le répertoire temporaire du système (généralement "/tmp" sous Linux ou "C:\\Users\\<name>\\AppData\\Local\\Temp" sous Windows).
- Le nom du fichier ressemblera à "myapp_1234567890.tmp".
- Le fichier existe déjà sur le disque, vous pouvez le manipuler comme un fichier normal.
Arguments de la méthode
- Le premier argument — le préfixe du nom de fichier (par exemple, "myapp_").
- Le second argument — le suffixe (par exemple, ".tmp"). Si vous ne l’indiquez pas, ce sera simplement ".tmp".
- Si les deux arguments sont null, le nom sera défini par défaut.
Où le fichier est-il enregistré ?
Par défaut, le fichier est enregistré dans le répertoire temporaire du système. Mais vous pouvez indiquer le vôtre :
Path tempDir = Paths.get("my_temp_folder");
Files.createDirectories(tempDir); // Créer s'il n'existe pas
Path tempFile = Files.createTempFile(tempDir, "prefix_", ".txt");
2. Création de répertoires temporaires : Files.createTempDirectory
Parfois, il ne faut pas seulement un fichier temporaire, mais un dossier temporaire entier — par exemple, pour décompresser une archive ou stocker temporairement de nombreux fichiers.
Exemple
import java.nio.file.*;
public class TempDirExample {
public static void main(String[] args) throws Exception {
// Crée un répertoire temporaire avec le préfixe "work_"
Path tempDir = Files.createTempDirectory("work_");
System.out.println("Dossier temporaire : " + tempDir);
// On peut y créer des fichiers
Path fileInTempDir = Files.createTempFile(tempDir, "file_", ".dat");
System.out.println("Fichier temporaire à l’intérieur : " + fileInTempDir);
}
}
Particularités :
- Le nom du dossier sera à peu près comme ceci : "work_1234567890".
- Par défaut — dans le répertoire temporaire du système, mais vous pouvez en indiquer un autre.
Indiquer le répertoire
Path baseDir = Paths.get("my_temp_work");
Files.createDirectories(baseDir);
Path tempDir = Files.createTempDirectory(baseDir, "session_");
3. Suppression des fichiers et répertoires temporaires
Voici l’un des principaux « pièges » de Java : les fichiers et dossiers temporaires ne sont pas supprimés automatiquement ! Si vous ne les enlevez pas, ils resteront sur le disque pendant des années (ou jusqu’au prochain nettoyage par le système).
Comment supprimer des fichiers temporaires ?
- Manuellement : une fois le travail terminé, appelez Files.delete(...) ou Files.deleteIfExists(...).
- À la fin du programme : vous pouvez utiliser la bonne vieille méthode File.deleteOnExit(), mais uniquement pour les objets de type File, et non Path.
Exemple : suppression d’un fichier temporaire
import java.nio.file.*;
public class TempFileDeleteExample {
public static void main(String[] args) throws Exception {
Path tempFile = Files.createTempFile("demo_", ".tmp");
System.out.println("Créé : " + tempFile);
// ... on travaille avec le fichier
// On supprime le fichier
Files.deleteIfExists(tempFile);
System.out.println("Supprimé : " + tempFile);
}
}
Utilisation de deleteOnExit()
import java.io.File;
public class DeleteOnExitDemo {
public static void main(String[] args) throws Exception {
File tempFile = File.createTempFile("legacy_", ".tmp");
System.out.println("Créé : " + tempFile);
// Marquer le fichier pour suppression à l’arrêt de la JVM
tempFile.deleteOnExit();
}
}
Attention !
La méthode deleteOnExit() ne fonctionne qu’avec File, pas avec Path. Si vous utilisez l’API moderne (Path et Files), supprimez manuellement.
Suppression des répertoires temporaires
Vous ne pouvez supprimer un dossier temporaire que s’il est vide :
Files.delete(tempDir); // lèvera une exception si quelque chose reste à l’intérieur
S’il y a des fichiers dans le dossier — supprimez-les d’abord, puis le dossier. On écrit généralement une petite méthode récursive pour cela.
4. Recommandations pratiques
Où stocker les fichiers temporaires ?
Répertoire temporaire du système :
Utilisez-le par défaut s’il n’y a pas d’exigences particulières. Vous pouvez obtenir le chemin comme ceci :
String tempDir = System.getProperty("java.io.tmpdir");
System.out.println("Dossier temporaire système : " + tempDir);
Dossier dédié :
Si la sécurité ou l’organisation sont importantes — créez un dossier séparé (par exemple, dans le répertoire de l’application).
Sécurité
- Ne stockez pas les fichiers temporaires dans des dossiers publics — surtout s’ils peuvent contenir quelque chose de confidentiel.
- Nettoyez les fichiers temporaires après utilisation — sinon ils peuvent s’accumuler et occuper de l’espace.
Nettoyage en cas d’erreurs
Si une erreur se produit pendant l’exécution du programme, n’oubliez pas de supprimer les fichiers temporaires. Pour cela, il est pratique d’utiliser des blocs try-finally :
Path tempFile = Files.createTempFile("task_", ".tmp");
try {
// on utilise le fichier
} finally {
Files.deleteIfExists(tempFile);
}
Fichiers temporaires et tests
Dans les tests, on utilise souvent des fichiers et dossiers temporaires pour isoler les données. Après le test — supprimez impérativement tout ce qui a été créé !
5. Exemple : répertoire de travail temporaire pour le traitement des données
Supposons que vous écriviez un programme qui traite une archive et extrait temporairement des fichiers. Pour cela, il est pratique de créer un dossier temporaire, puis de le supprimer une fois le travail terminé.
import java.nio.file.*;
import java.io.IOException;
public class TempWorkDirExample {
public static void main(String[] args) throws IOException {
// Nous créons un répertoire temporaire
Path tempWorkDir = Files.createTempDirectory("unzip_");
System.out.println("Répertoire de travail temporaire : " + tempWorkDir);
try {
// Ici, on pourrait décompresser une archive
Path tempFile = Files.createTempFile(tempWorkDir, "file_", ".txt");
Files.writeString(tempFile, "Données temporaires pour le traitement");
// ... on travaille avec les fichiers
} finally {
// Nous supprimons tous les fichiers du dossier puis le dossier lui-même
Files.walk(tempWorkDir)
.sorted((a, b) -> b.compareTo(a)) // d’abord les fichiers, puis les dossiers
.forEach(path -> {
try {
Files.deleteIfExists(path);
} catch (IOException ex) {
System.err.println("Impossible de supprimer " + path + " : " + ex.getMessage());
}
});
System.out.println("Le dossier temporaire et les fichiers ont été supprimés.");
}
}
}
Remarquez :
On supprime d’abord tous les fichiers, puis le dossier lui-même. Le tri est nécessaire pour éviter d’essayer de supprimer un dossier avant d’avoir supprimé son contenu.
6. Erreurs courantes lors de l’utilisation des fichiers temporaires
Erreur n°1 : vous avez oublié de supprimer un fichier ou un dossier temporaire. Le problème le plus fréquent — les fichiers temporaires restent sur le disque, s’accumulent et finissent par « encombrer » le système. C’est particulièrement critique pour les applications serveur et les processus de longue durée.
Erreur n°2 : vous utilisez deleteOnExit() pour Path. La méthode deleteOnExit() ne fonctionne qu’avec la classe File, pas avec Path. Si vous utilisez l’API moderne, il faudra supprimer manuellement.
Erreur n°3 : vous essayez de supprimer un dossier non vide avec Files.delete. La méthode Files.delete() ne supprime que les répertoires vides. S’il reste quelque chose à l’intérieur — une exception sera levée. Pour supprimer des répertoires non vides, utilisez un parcours récursif et supprimez tous les fichiers.
Erreur n°4 : vous créez des fichiers temporaires dans le répertoire de travail du projet. Cela peut conduire à la suppression accidentelle de fichiers importants ou à de la confusion. Il vaut mieux utiliser le dossier temporaire du système ou un dossier dédié pour les fichiers temporaires de l’application.
Erreur n°5 : vous ne traitez pas les exceptions lors de la suppression des fichiers temporaires. Si le fichier est déjà supprimé ou verrouillé, la tentative de suppression peut lever une exception. Utilisez Files.deleteIfExists() et gérez les erreurs.
GO TO FULL VERSION