Controlla se un file o una directory esiste in Java

1. Panoramica

In questo rapido tutorial, acquisiremo familiarità con diversi modi per verificare l'esistenza di un file o di una directory.

Innanzitutto, inizieremo con le moderne API NIO e poi tratteremo gli approcci IO legacy.

2. Utilizzo di java.nio.file.Files

Per verificare se esiste un file o una directory, siamo in grado di sfruttare le Files.exists (Path) metodo . Come è chiaro dalla firma del metodo, dovremmo prima ottenere un percorso per il file o la directory desiderati. Quindi possiamo passare quel percorso al metodo Files.exists (Path) :

Path path = Paths.get("does-not-exist.txt"); assertFalse(Files.exists(path));

Poiché il file non esiste, restituisce false . Vale anche la pena ricordare che se il metodo Files.exists (Path) incontra un'IOException , restituirà anche false .

D'altra parte, quando il file specificato esiste, restituirà true come previsto:

Path tempFile = Files.createTempFile("baeldung", "exist-article"); assertTrue(Files.exists(tempFile));

Qui stiamo creando un file temporaneo e quindi chiamiamo il metodo Files.exists (Path) .

Funziona anche per le directory :

Path tempDirectory = Files.createTempDirectory("baeldung-exists"); assertTrue(Files.exists(tempDirectory));

Se vogliamo specificamente sapere se esiste un file o una directory, possiamo anche utilizzare i metodi Files.isDirectory (Path) o Files.isRegularFile (Path) :

assertTrue(Files.isDirectory(tempDirectory)); assertFalse(Files.isDirectory(tempFile)); assertTrue(Files.isRegularFile(tempFile));

C'è anche un metodo notExists (Path) che restituisce true se il percorso specificato non esiste:

assertFalse(Files.notExists(tempDirectory));

A volte Files.exists (Path) restituisce false perché non possediamo le autorizzazioni file richieste . In tali scenari, possiamo utilizzare il metodo Files.isReadable (Path) per assicurarci che il file sia effettivamente leggibile dall'utente corrente:

assertTrue(Files.isReadable(tempFile)); assertFalse(Files.isReadable(Paths.get("/root/.bashrc")));

2.1. Collegamenti simbolici

Per impostazione predefinita, il metodo Files.exists (Path) segue i collegamenti simbolici . Se il file A ha un collegamento simbolico al file B , il metodo Files.exists (A) restituisce true se e solo se il file B esiste già:

Path target = Files.createTempFile("baeldung", "target"); Path symbol = Paths.get("test-link-" + ThreadLocalRandom.current().nextInt()); Path symbolicLink = Files.createSymbolicLink(symbol, target); assertTrue(Files.exists(symbolicLink));

Ora se cancelliamo la destinazione del collegamento, Files.exists (Path) restituirà false :

Files.deleteIfExists(target); assertFalse(Files.exists(symbolicLink));

Poiché la destinazione del collegamento non esiste più, seguire il collegamento non porterà a nulla e Files.exists (Path) restituirà false .

È anche possibile non seguire i collegamenti simbolici passando un LinkOption appropriato come secondo argomento:

assertTrue(Files.exists(symbolicLink, LinkOption.NOFOLLOW_LINKS));

Poiché il collegamento stesso esiste, il metodo Files.exists (Path) restituisce true. Inoltre, possiamo verificare se un percorso è un collegamento simbolico utilizzando il metodo Files.isSymbolicLink (Path) :

assertTrue(Files.isSymbolicLink(symbolicLink)); assertFalse(Files.isSymbolicLink(target));

3. Utilizzo di java.io.File

Se stiamo utilizzando Java 7 o una versione più recente di Java, si consiglia vivamente di utilizzare le moderne API Java NIO per questi tipi di requisiti .

Tuttavia, per assicurarci che un file o una directory esista nel mondo IO legacy di Java, possiamo chiamare il metodo exist () sulle istanze di file :

assertFalse(new File("invalid").exists());

Se il file o la directory esiste già, restituirà true :

Path tempFilePath = Files.createTempFile("baeldung", "exist-io"); Path tempDirectoryPath = Files.createTempDirectory("baeldung-exists-io"); File tempFile = new File(tempFilePath.toString()); File tempDirectory = new File(tempDirectoryPath.toString()); assertTrue(tempFile.exists()); assertTrue(tempDirectory.exists());

Come mostrato sopra, al metodo exist () non interessa se si tratta di un file o di una directory. Pertanto, finché esiste, restituirà vero .

Il metodo isFile () , tuttavia, restituisce true se il percorso specificato è un file esistente:

assertTrue(tempFile.isFile()); assertFalse(tempDirectory.isFile());

Allo stesso modo, il metodo isDirectory () restituisce true se il percorso specificato è una directory esistente:

assertTrue(tempDirectory.isDirectory()); assertFalse(tempFile.isDirectory());

Infine, il metodo canRead () restituisce true se il file è leggibile:

assertTrue(tempFile.canRead()); assertFalse(new File("/root/.bashrc").canRead());

Quando restituisce false , il file non esiste o l'utente corrente non possiede l'autorizzazione di lettura sul file.

4. Conclusione

In questo breve tutorial, abbiamo visto come assicurarsi che un file o una directory esista in Java. Lungo la strada, abbiamo parlato del NIO moderno e delle API IO legacy. Inoltre, abbiamo visto come l'API NIO gestisce i collegamenti simbolici.

Come al solito, tutti gli esempi sono disponibili su GitHub.