Como verifico se existe um arquivo em Java?

842

Como posso verificar se existe um arquivo antes de abri-lo para leitura em Java (o equivalente ao Perl -e $filename )?

A única pergunta semelhante sobre o SO lida com a gravação do arquivo e, portanto, foi respondida usando o FileWriterque obviamente não é aplicável aqui.

Se possível, eu preferiria uma chamada de API real retornando verdadeiro / falso, em vez de alguns "API de chamada para abrir um arquivo e capturar quando ela lança uma exceção, na qual você verifica 'sem arquivo' no texto", mas eu posso viver com o último.

DVK
fonte
3
Também quero acrescentar que você gostaria de verificar se há permissões de arquivo apropriado: docs.oracle.com/javase/6/docs/api/java/io/File.html java.io.File tem métodos canRead, canWritee canExecutepara verificar que .
Kirkland
6
Note-se que isso é perigoso. O sistema de arquivos pode mudar a qualquer momento, inclusive logo após o retorno do método "este arquivo existe". Como você precisa lidar com esse caso de qualquer maneira, esse método é de utilidade questionável. Se você deseja abrir o arquivo, a maneira correta de fazer isso é abrir o arquivo e manipular a exceção relevante.
21716 Kevin
1
@ Kevin bom ponto, mas é de utilidade inquestionável no ambiente não-concorrente, que passou a ser o caso, eu estava precisando isto;)
DVK
@DVK: Você está executando em um sistema operacional multitarefa preventivamente? Ou isso, ou é um chip Java especialmente projetado . Se for o primeiro, você está em um ambiente simultâneo. Outros processos podem alterar o sistema de arquivos sob você.
19416 Kevin
2
@ Kevin, não importa, mas é um aplicativo de thread único projetado para uso pessoal. As chances de que seu arquivo dedicado seja de alguma forma criado / alterado a partir dele são incrivelmente baixas.
DVK

Respostas:

1342

Usando java.io.File:

File f = new File(filePathString);
if(f.exists() && !f.isDirectory()) { 
    // do something
}
Sean AO Harney
fonte
15
Existem alguns casos em que existe () retornará um resultado incorreto. Por exemplo, ao usar um sistema de arquivos NFS, há um problema com identificadores antigos : bugs.java.com/bugdatabase/view_bug.do?bug_id=5003595 É meio obscuro, mas foi a causa de alguns erros frustrantes no código de produção antes.
CAW
22
Use em if(f.isFile())vez disso.
31418 Leon
1
lembre-se de usar filePathString.trim () para evitar espaços em branco
Asim
427

Eu recomendaria usar em isFile()vez de exists(). Na maioria das vezes, você procura verificar se o caminho aponta para um arquivo, não apenas que ele existe. Lembre-se de que exists()retornará true se o caminho apontar para um diretório.

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

new File("C:/").exists() retornará true, mas não permitirá que você o abra e leia como um arquivo.

Chris Dail
fonte
1
@ ylun.ca O exemplo inclui subdiretórios? Se você deseja perguntar se, dado um diretório atual de /path, new File("file.txt").exists()retornará truese o caminho completo correto for /path/to/file.txt, a resposta é um grande não (a menos que /path/file.txtexista outro arquivo ).
Matthew Leia
149

Usando o nio no 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 ambos existse notExistsretornar falso, a existência do arquivo não poderá ser verificada. (talvez não haja acesso direto a esse caminho)

Você pode verificar se pathé um diretório ou arquivo regular.

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

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

Por favor, verifique este tutorial do Java SE 7 .

Wonil
fonte
2
Quais são as vantagens comparadas com o novo File (path) .exists ()? Para um palin existe cheque
Raghu K Nair
2
O @RaghuKNair java.nio.file.Files.exists()é muito mais rápido do que java.io.File.exists()(no meu pequeno benchmark no único computador que testei: Windows Server 2012 executando Java 1.7.0_45 x64).
Matthieu
1
Eu apenas tentei eu mesmo e java.nio.file.Files.exists()foi 5 vezes mais lento que java.io.File.exists. (Win7 Java 1.7.0_79 - x86)
ParkerHalo
Isso também tem a desvantagem de que Paths.get lança uma exceção se a cadeia não é válido
Richard
46

Usando o Java 8:

if(Files.exists(Paths.get(filePathString))) { 
    // do something
}
Wendel
fonte
2
Files.exists()leva dois argumentos. Normalmente, você vai querer algo parecido Files.exists(path, LinkOption.NOFOLLOW_LINKS ).
Mike C
1
@ MikeC Gostaria de saber qual método é chamado sem o segundo argumento. O Docu nem mostra nenhuma informação sobre isso.
PowerFlower
1
@ PowerFlower: existe apenas um método Files.exists (). Sem passar o segundo argumento, ele ainda chama o mesmo método. O segundo argumento é variável varargs e pode passar 0 ou mais LinkOptions.
TK8
27
File f = new File(filePathString); 

Isso não criará um arquivo físico. Apenas criará um objeto da classe File. Para criar fisicamente um arquivo, você deve explicitamente criá-lo:

f.createNewFile();

Portanto, f.exists()pode ser usado para verificar se esse arquivo existe ou não.

rizwan
fonte
25
f.isFile() && f.canRead()
jhumble
fonte
2
O pearl's -etambém garante que o aplicativo "possa ler" o arquivo?
Expiação limitada
16

Existem várias maneiras de conseguir isso.

  1. No caso de apenas existir. Pode ser um arquivo ou um diretório.

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

    File f = new File("/path/to/file"); 
      if(f.exists() && f.isFile()) {}
    
  3. Verifique o diretório.

    File f = new File("/path/to/file"); 
      if(f.exists() && f.isDirectory()) {}
    
  4. Caminho de Java 7.

    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
    
Raghu K Nair
fonte
14

Você pode usar o seguinte: File.exists()

Francis Upton IV
fonte
14

o primeiro hit para "arquivo java existe" no 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 "));
    }
}
apenas alguém
fonte
1
Não há necessidade de verificar se f! = Null antes de verificar f.exists, se a nova palavra-chave falhar, ela gerará uma exceção.
23415 Sean Sean Harney
não há verificação se f! = null. f + (...) usa java.io.File.toString
apenas alguém
@just na verdade, ele usa String.valueOf(), que lida com valores nulos
GreenGiant
12

Não. Basta pegar o FileNotFoundException.arquivo O sistema de arquivos precisa testar se o arquivo existe de qualquer maneira. Não faz sentido fazer tudo isso duas vezes e vários motivos para não fazê-lo, como:

  • dobrar o código
  • o problema da janela de tempo em que o arquivo pode existir quando você testar, mas não quando abrir, ou vice-versa, e
  • o fato de que, como mostra a existência desta pergunta, você pode fazer o teste errado e obter a resposta errada.

Não tente adivinhar o sistema. Sabe disso E não tente prever o futuro. Em geral, a melhor maneira de testar se algum recurso está disponível é apenas tentar usá-lo.

Marquês de Lorne
fonte
E se eu quiser verificar a cada hora para ver se um arquivo foi depositado em um local diretamente. Eu tenho um projeto webMethods que precisa verificar se um arquivo específico foi carregado em uma unidade específica. Como isso seria feito. Digamos que eu queira verificar a cada hora para ver se o arquivo está lá. Eu posso usar Java para escrever uma classe que faz isso provavelmente com um temporizador de algum tipo.
Doug Hauf 23/01
2
Capturar uma exceção é muito mais caro. No meu teste, verificar o novo File (). Existir () foi mais de 10 vezes mais rápido do que capturar FileNotFoundException. Portanto, se você tiver um cenário em que normalmente há arquivos ausentes (como cache de disco), a exceção está errada. Além disso, adivinhar o sistema é legal.
Nick Frolov
1
@Gnawer Você não abordou nenhum dos problemas que levantei; a exceção é lançada apenas quando o arquivo não pode ser aberto; e as operações que ocorrem uma vez por hora não requerem micro-otimização. Sua sentença final é um disparate.
Marquês de Lorne
1
@DougHauf no seu caso, não há problema, pois você não tenta fazer nada depois de verificar a existência. Mas o OP pediu especificamente para verificar antes da abertura. Nesse caso, é melhor apenas tentar / pegar o arquivo aberto.
Dan Passaro
8

Para mim, uma combinação da resposta aceita por Sean AO Harney e o comentário resultante de Cort3z parece ser a melhor solução.

Utilizou o seguinte fragmento:

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

Espero que isso possa ajudar alguém.

X-Fate
fonte
4

Eu sei que estou um pouco atrasado neste tópico. No entanto, aqui está a minha resposta, válida desde o Java 7 e superior.

O seguinte trecho

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

é perfeitamente satisfatório, porque o método isRegularFileretorna falsese o arquivo não existir. Portanto, não há necessidade de verificar se Files.exists(...).

Observe que outros parâmetros são opções que indicam como os links devem ser manipulados. Por padrão, links simbólicos são seguidos.

Da documentação do Java Oracle

avi.elkharrat
fonte
Da documentação do sonar: O método Files.exists tem desempenho notavelmente ruim no JDK 8 e pode retardar significativamente um aplicativo quando usado para verificar arquivos que realmente não existem. O mesmo vale para Files.notExists, Files.isDirectorye Files.isRegularFile. a melhor alternativa para isso é:path.toFile().exists()
Genaut
4

Também vale a pena se familiarizar com o Commons FileUtils https://commons.apache.org/proper/commons-io/javadocs/api-2.5/org/apache/commons/io/FileUtils.html Isso possui métodos adicionais para gerenciar arquivos e geralmente melhor que o JDK.

peter.murray.rust
fonte
19
Maneira de não responder à pergunta. Concordo que o commons tem muitas coisas úteis, mas talvez possamos dar um passo adiante e fornecer uma resposta à pergunta que o OP fez.
Demongolem
4
Ele deu uma resposta suficiente para mim.
bulltorious
3

Por exemplo, se você possui um diretório de arquivos e deseja verificar se ele existe

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

boolean exists = tmpDir.exists();

exists retornará false se o arquivo não existir

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

ID127898
fonte
2

Exemplo simples com boas práticas de codificação e abrangendo todos os casos:

 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);
            }
        }
    }

Referência e mais exemplos em

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

Amandeep Singh
fonte
1

Se você deseja procurar por um Fileem um diretóriodir

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

e verifique o checkresultado

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

fará o truque

user4833142
fonte
1

Não use o construtor File com String.
Isso pode não funcionar!
Em vez disso, use o URI:

File f = new File(new URI("file:///"+filePathString.replace('\\', '/')));
if(f.exists() && !f.isDirectory()) { 
    // to do
}
iviorel
fonte
Pode não funcionar porque não? E como o uso de um URI corrige isso?
Marquês de Lorne
Tivemos um problema. f.exists () era verdade e até conseguimos o conteúdo do arquivo. O problema era que o caminho estava errado, mas o nome do arquivo estava OK, mesmo este era outro arquivo. Alterar a chamada do construtor com o URI, corrigiu o problema.
iviorel
1

File.exists()para verificar se existe um arquivo, ele retornará um valor booleano para indicar o status da operação de verificação; true se o arquivo existe; false se não existir.

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

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

Você pode usar o seguinte código para verificar:

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;
        }
    }
}
Pankti
fonte
0

Você pode fazer assim

import java.nio.file.Paths;

String file = "myfile.sss";
if(Paths.get(file).toFile().isFile()){
    //...do somethinh
}
Rodrigo Pavan
fonte
Para ter em conta a sua resposta tem o melhor desempenho em comparação com File.is Exist()ou Files.isRegularFile()em JDK 8
Cristian Chaparro A.
0

Existe um objetivo específico para projetar esses métodos. Não podemos dizer que use alguém para verificar se o arquivo existe ou não.

  1. isFile () : testa se o arquivo indicado por esse caminho abstrato é um arquivo normal.
  2. existe () : testa se o arquivo ou diretório indicado por esse caminho abstrato existe. docs.oracle.com
Atul Jain
fonte
-5

Para verificar se existe um arquivo, basta importar a biblioteca 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/

Yassine
fonte
2
Isso não acrescenta nada. O que você diz foi dito em várias respostas. Por favor, não produza ruído.
klutt