Come posso verificare se esiste un file in Java?

Come posso verificare se esiste un file prima di aprirlo per la lettura in Java (l'equivalente di Perl -e $filename )?

L'unica domanda simile su SO riguarda la scrittura del file e quindi è stata data una risposta usando FileWriterche ovviamente non è applicabile qui.

Se possibile, preferirei una vera chiamata API che restituisca vero / falso rispetto ad alcune "Chiama API per aprire un file e catturare quando genera un'eccezione che controlli" nessun file "nel testo", ma posso convivere con l'ultimo.

Utilizzando java.io.File:

File f = new File(filePathString);
if(f.exists() && !f.isDirectory()) { 
    // do something
}

Consiglierei di utilizzare isFile()invece di exists(). La maggior parte delle volte stai cercando di verificare se il percorso punta a un file non solo che esiste. Ricorda che exists()tornerà vero se il tuo percorso punta a una directory.

new File("path/to/file.txt").isFile();

new File("C:/").exists() restituirà true ma non ti consentirà di aprirlo e leggerlo come file.

Usando nio in Java SE 7,

import java.nio.file.*;

Path path = Paths.get(filePathString);

if (Files.exists(path)) {
  // file exist
}

if (Files.notExists(path)) {
  // file is not exist
}

Se entrambi existse notExistsrestituiscono false, non è possibile verificare l'esistenza del file. (forse nessun accesso proprio a questo percorso)

Puoi controllare se pathè una directory o un file normale.

if (Files.isDirectory(path)) {
  // path is directory
}

if (Files.isRegularFile(path)) {
  // path is regular file
}

Controlla questo tutorial su Java SE 7 .

Utilizzando Java 8:

if(Files.exists(Paths.get(filePathString))) { 
    // do something
}

File f = new File(filePathString); 

Questo non creerà un file fisico. Creerà semplicemente un oggetto della classe File. Per creare fisicamente un file devi crearlo esplicitamente:

f.createNewFile();

Quindi f.exists()può essere usato per verificare se esiste un file del genere.

f.isFile() && f.canRead()

Esistono diversi modi per raggiungere questo obiettivo.

1. In caso di esistenza. Potrebbe essere un file o una directory.

   new File("/path/to/file").exists();

2. Controlla il file

   File f = new File("/path/to/file"); 
     if(f.exists() && f.isFile()) {}

3. Controlla la directory.

   File f = new File("/path/to/file"); 
     if(f.exists() && f.isDirectory()) {}

4. Java 7 vie.

   Path path = Paths.get("/path/to/file");
   Files.exists(path)  // Existence 
   Files.isDirectory(path)  // is Directory
   Files.isRegularFile(path)  // Regular file 
   Files.isSymbolicLink(path)  // Symbolic Link

È possibile utilizzare quanto segue: File.exists()

primo colpo per "esiste un file java" su google:

import java.io.*;

public class FileTest {
    public static void main(String args[]) {
        File f = new File(args[0]);
        System.out.println(f + (f.exists()? " is found " : " is missing "));
    }
}

Non farlo. Basta catturare FileNotFoundException.Il file system deve verificare se il file esiste comunque. Non ha senso fare tutto ciò due volte, e diversi motivi per non farlo, come:

• raddoppia il codice
• il problema della finestra di temporizzazione in base al quale il file potrebbe esistere durante il test ma non all'apertura, o viceversa, e
• il fatto che, come dimostra l'esistenza di questa domanda, potresti fare il test sbagliato e ottenere la risposta sbagliata.

Non provare a indovinare il sistema. Lo sa. E non provare a prevedere il futuro. In generale, il modo migliore per verificare se una risorsa è disponibile è solo provare a usarla.

Per me una combinazione della risposta accettata da Sean AO Harney e il conseguente commento di Cort3z sembra essere la soluzione migliore.

Usato il seguente frammento:

File f = new File(filePathString);
if(f.exists() && f.isFile()) {
    //do something ...
}

Spero che questo possa aiutare qualcuno.

So di essere un po 'in ritardo in questa discussione. Tuttavia, ecco la mia risposta, valida da Java 7 in poi.

Il frammento seguente

if(Files.isRegularFile(Paths.get(pathToFile))) {
    // do something
}

è perfettamente saziante, perché il metodo isRegularFilerestituisce falsese il file non esiste. Pertanto, non è necessario verificare se Files.exists(...).

Si noti che altri parametri sono opzioni che indicano come devono essere gestiti i collegamenti. Per impostazione predefinita, vengono seguiti i collegamenti simbolici.

Dalla documentazione Java Oracle

Vale anche la pena familiarizzare con Commons FileUtils https://commons.apache.org/proper/commons-io/javadocs/api-2.5/org/apache/commons/io/FileUtils.html Questo ha metodi aggiuntivi per la gestione di file e spesso meglio di JDK.

Ad esempio, se si dispone di una directory di file e si desidera verificare se esiste

File tmpDir = new File("/var/tmp");

boolean exists = tmpDir.exists();

exists restituirà false se il file non esiste

fonte: https://alvinalexander.com/java/java-file-exists-directory-exists

Esempio semplice con buone pratiche di codifica e che copre tutti i casi:

 private static void fetchIndexSafely(String url) throws FileAlreadyExistsException {
        File f = new File(Constants.RFC_INDEX_LOCAL_NAME);
        if (f.exists()) {
            throw new FileAlreadyExistsException(f.getAbsolutePath());
        } else {
            try {
                URL u = new URL(url);
                FileUtils.copyURLToFile(u, f);
            } catch (MalformedURLException ex) {
                Logger.getLogger(RfcFetcher.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IOException ex) {
                Logger.getLogger(RfcFetcher.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

Riferimenti e altri esempi su

https://zgrepcode.com/examples/java/java/nio/file/filealreadyexistsexception-implementations

Se si desidera verificare la presenza di a Filein una directorydir

String directoryPath = dir.getAbsolutePath()
boolean check = new File(new File(directoryPath), aFile.getName()).exists();

e controlla il checkrisultato

new File("/path/to/file").exists(); 

farà il trucco

Non usare il costruttore di file con String.
Questo potrebbe non funzionare!
Invece di utilizzare questo URI:

File f = new File(new URI("file:///"+filePathString.replace('\\', '/')));
if(f.exists() && !f.isDirectory()) { 
    // to do
}

File.exists()per verificare se esiste un file, verrà restituito un valore booleano per indicare lo stato dell'operazione di controllo; vero se il file esiste; falso se non esiste.

File f = new File("c:\\test.txt");

if(f.exists()){
    System.out.println("File existed");
}else{
    System.out.println("File not found!");
}

È possibile utilizzare il seguente codice per verificare:

import java.io.File;
class Test{
    public static void main(String[] args){
        File f = new File(args[0]); //file name will be entered by user at runtime
        System.out.println(f.exists()); //will print "true" if the file name given by user exists, false otherwise

        if(f.exists())
        {
             //executable code;
        }
    }
}

Puoi farlo in questo modo

import java.nio.file.Paths;

String file = "myfile.sss";
if(Paths.get(file).toFile().isFile()){
    //...do somethinh
}

C'è uno scopo specifico per progettare questi metodi. Non possiamo dire di usare nessuno per controllare l'esistenza o meno del file.

1. isFile () : verifica se il file indicato da questo percorso astratto è un file normale.
2. esiste () : verifica se esiste il file o la directory indicati da questo percorso astratto. docs.oracle.com

Per verificare se esiste un file, importa semplicemente la libreria java.io. *

File f = new File(“C:\\File Path”);

if(f.exists()){
        System.out.println(“Exists”);        //if file exists
}else{
        System.out.println(“Doesn't exist”);         //if file doesn't exist
}

Fonte: http://newsdivariotipo.altervista.org/java-come-controllare-se-un-file-esiste/