1. Creazione dei file
Creare file a livello di codice è spesso necessario: per i log, dati temporanei, esportazione di report, importazione di dati, salvataggio delle impostazioni e molto altro. In Java, per questo, come probabilmente avete già intuito, è meglio utilizzare l'API moderna — java.nio.file.
Strumento principale: Files.createFile(Path)
Questo metodo crea un nuovo file nel percorso indicato. Se il file esiste già, verrà generata un'eccezione.
Esempio: creiamo un file di testo nella directory corrente
import java.nio.file.*;
public class CreateFileExample {
public static void main(String[] args) {
Path path = Path.of("hello.txt");
try {
Files.createFile(path);
System.out.println("File creato: " + path.toAbsolutePath());
} catch (FileAlreadyExistsException e) {
System.out.println("Il file esiste già: " + path);
} catch (Exception e) {
System.out.println("Errore durante la creazione del file: " + e.getMessage());
}
}
}
Da notare:
Files.createFile solleva FileAlreadyExistsException se il file esiste già. Per questo spesso si verifica l'esistenza prima di creare il file.
Verifica dell'esistenza del file
Path path = Path.of("hello.txt");
if (!Files.exists(path)) {
Files.createFile(path);
}
Suggerimento:
La verifica dell'esistenza del file non protegge dalle race condition tra thread, ma per la maggior parte degli scenari d'uso è un approccio più che valido.
In breve: cosa succede durante la creazione di un file?
- Se il file non esiste e il percorso è corretto, viene creato un nuovo file vuoto.
- Se il file esiste già, viene lanciata un'eccezione.
- Se il percorso non è valido, mancano i permessi o la cartella non esiste, verrà lanciata un'altra eccezione (IOException, NoSuchFileException, ecc.).
2. Creazione delle directory
Differenza tra Files.createDirectory e Files.createDirectories
- Files.createDirectory(Path) — crea solo una cartella. Se la cartella padre non esiste, si verifica un errore.
- Files.createDirectories(Path) — crea l'intera catena di cartelle mancanti (come un mago che costruisce una scala proprio sotto i tuoi piedi).
Esempio: creiamo una singola cartella
Path dir = Path.of("data");
try {
Files.createDirectory(dir);
System.out.println("Cartella creata: " + dir.toAbsolutePath());
} catch (FileAlreadyExistsException e) {
System.out.println("La cartella esiste già: " + dir);
} catch (Exception e) {
System.out.println("Errore durante la creazione della cartella: " + e.getMessage());
}
Esempio: creiamo una struttura di cartelle annidate
Path nested = Path.of("data/reports/2024");
try {
Files.createDirectories(nested);
System.out.println("Struttura di cartelle creata: " + nested.toAbsolutePath());
} catch (Exception e) {
System.out.println("Errore durante la creazione della struttura: " + e.getMessage());
}
Nota: se alcune cartelle esistono già, createDirectories non si spaventa — crea semplicemente quelle mancanti. Se si usa createDirectory per una cartella annidata e quella padre non esiste ancora — si avrà un errore.
Tabella: confronto dei metodi di creazione delle cartelle
| Metodo | Crea solo una cartella | Crea cartelle annidate | Non fallisce se alcune esistono già |
|---|---|---|---|
|
✔ | ✗ | ✗ |
|
✔ | ✔ | ✔ |
3. Eliminazione dei file
Eliminare i file è un po' come buttare la spazzatura: l'importante è non buttare via qualcosa di utile! In Java ci sono due metodi principali per farlo:
- Files.delete(Path) — elimina un file o una cartella vuota. Se il file non esiste, viene lanciata un'eccezione.
- Files.deleteIfExists(Path) — elimina il file, ma se non esiste semplicemente non fa nulla.
Esempio: eliminiamo un file temporaneo
Path tempFile = Path.of("temp.txt");
try {
Files.delete(tempFile);
System.out.println("File eliminato: " + tempFile);
} catch (NoSuchFileException e) {
System.out.println("File non trovato: " + tempFile);
} catch (DirectoryNotEmptyException e) {
System.out.println("La cartella non è vuota: " + tempFile);
} catch (Exception e) {
System.out.println("Errore durante l'eliminazione: " + e.getMessage());
}
Una variante più sicura
boolean deleted = Files.deleteIfExists(tempFile);
if (deleted) {
System.out.println("Il file è stato eliminato.");
} else {
System.out.println("File non trovato — nulla da eliminare.");
}
Importante!
- Se il file è aperto in un altro programma, può essere lanciata un'eccezione (ad esempio su Windows).
- Se si tenta di eliminare una cartella non vuota, si otterrà l'errore DirectoryNotEmptyException.
4. Eliminazione delle directory
Le cartelle in Java si eliminano più o meno come i file. Con una sola sfumatura: i metodi standard eliminano solo le cartelle vuote.
Esempio: eliminiamo una cartella vuota
Path emptyDir = Path.of("empty_folder");
try {
Files.delete(emptyDir);
System.out.println("Cartella eliminata: " + emptyDir);
} catch (DirectoryNotEmptyException e) {
System.out.println("La cartella non è vuota: " + emptyDir);
} catch (NoSuchFileException e) {
System.out.println("Cartella non trovata: " + emptyDir);
} catch (Exception e) {
System.out.println("Errore durante l'eliminazione della cartella: " + e.getMessage());
}
Che fare con le cartelle non vuote?
Per eliminare directory non vuote sarà necessario eliminare ricorsivamente tutti i file e le sottocartelle contenuti. È un argomento per una lezione a parte (e un'avventura a sé), ma se non potete aspettare, ecco il codice: studiatelo e provate a replicarlo:
import java.nio.file.*;
import java.io.IOException;
public class DeleteDirectoryRecursively {
public static void deleteRecursively(Path path) throws IOException {
if (Files.isDirectory(path)) {
try (var entries = Files.list(path)) {
for (Path entry : entries.toList()) {
deleteRecursively(entry);
}
}
}
Files.delete(path);
}
}
Attenzione:
Questo codice eliminerà tutto ciò che si trova all'interno della cartella! Usatelo con cautela.
5. Consigli pratici
Verifica dell'esistenza prima di eliminare
if (Files.exists(path)) {
Files.delete(path);
} else {
System.out.println("Il file/la cartella non esiste.");
}
Ma se usate deleteIfExists, non è necessario.
Gestione delle eccezioni
Lavorando con i file spesso ci imbattiamo in imprevisti. Java per questo solleva diverse eccezioni:
- NoSuchFileException — file o cartella non trovati. Ad esempio, si tenta di aprire qualcosa che è già stato eliminato.
- DirectoryNotEmptyException — si vuole eliminare una cartella ma al suo interno c'è ancora qualcosa.
- IOException — avviso generico: qualcosa è andato storto. Le cause possono variare — mancanza di permessi, file in uso da un altro programma, percorso non valido.
Schema visivo: metodi principali
+-------------------+ +--------------------+
| Files.createFile | ----> | Nuovo file |
+-------------------+ +--------------------+
+---------------------+ +--------------------+
| Files.createDirectory|----> | Nuova cartella |
+---------------------+ +--------------------+
+-------------------+ +--------------------+
| Files.delete | ----> | File/cartella elim.|
+-------------------+ +--------------------+
(ma solo se la cartella è vuota!)
6. Errori tipici nella creazione e nell'eliminazione di file e cartelle
Errore n. 1: si tenta di creare un file/una cartella che esiste già. I metodi Files.createFile e Files.createDirectory sollevano un'eccezione se l'oggetto esiste già. Soluzione — verificare in anticipo l'esistenza oppure gestire l'eccezione.
Errore n. 2: si tenta di creare una cartella annidata con createDirectory, ma la cartella padre non esiste ancora. In questo caso si ottiene NoSuchFileException. Usate createDirectories per creare la catena di cartelle.
Errore n. 3: si tenta di eliminare una cartella non vuota con Files.delete. Si otterrà DirectoryNotEmptyException. Per eliminare directory non vuote serve la ricorsione.
Errore n. 4: mancano i permessi per creare/eliminare nella directory indicata. Verrà lanciata AccessDeniedException o IOException. Eseguite il programma con i permessi necessari oppure usate cartelle accessibili.
Errore n. 5: file in uso da un altro processo. Su Windows (e talvolta su altri sistemi operativi) non è possibile eliminare un file se è aperto da un altro programma. Si otterrà una IOException. Chiudete tutte le applicazioni che lo utilizzano prima di eliminarlo.
Errore n. 6: uso di percorsi relativi senza sapere «dove vi trovate». Il file viene creato in un posto diverso da quello atteso. Per sicurezza usate toAbsolutePath() e stampate il percorso a schermo.
GO TO FULL VERSION