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.