Como excluir uma pasta com arquivos usando Java

Quero criar e excluir um diretório usando Java, mas não está funcionando.

File index = new File("/home/Work/Indexer1");
if (!index.exists()) {
    index.mkdir();
} else {
    index.delete();
    if (!index.exists()) {
        index.mkdir();
    }
}

Java não é capaz de excluir pastas com dados. Você deve excluir todos os arquivos antes de excluir a pasta.

Use algo como:

String[]entries = index.list();
for(String s: entries){
    File currentFile = new File(index.getPath(),s);
    currentFile.delete();
}

Então você poderá excluir a pasta usando Não index.delete() testado!

Apenas uma linha.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

Documentação aqui

Isso funciona e, embora pareça ineficiente pular o teste de diretório, não é: o teste acontece imediatamente em listFiles().

void deleteDir(File file) {
    File[] contents = file.listFiles();
    if (contents != null) {
        for (File f : contents) {
            deleteDir(f);
        }
    }
    file.delete();
}

Atualizar, para evitar seguir links simbólicos:

void deleteDir(File file) {
    File[] contents = file.listFiles();
    if (contents != null) {
        for (File f : contents) {
            if (! Files.isSymbolicLink(f.toPath())) {
                deleteDir(f);
            }
        }
    }
    file.delete();
}

Eu prefiro esta solução em java 8:

  Files.walk(pathToBeDeleted)
    .sorted(Comparator.reverseOrder())
    .map(Path::toFile)
    .forEach(File::delete);

Deste site: http://www.baeldung.com/java-delete-directory

No JDK 7 você pode usar Files.walkFileTree()e Files.deleteIfExists()deletar uma árvore de arquivos. (Exemplo: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )

No JDK 6, uma maneira possível é usar FileUtils.deleteQuietly do Apache Commons, que removerá um arquivo, um diretório ou um diretório com arquivos e subdiretórios.

Usando o Apache Commons-IO, segue uma linha:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

Este é (ligeiramente) mais desempenho do que FileUtils.deleteDirectory.

Como mencionado, o Java não é capaz de excluir uma pasta que contém arquivos, portanto, primeiro exclua os arquivos e depois a pasta.

Aqui está um exemplo simples para fazer isso:

import org.apache.commons.io.FileUtils;



// First, remove files from into the folder 
FileUtils.cleanDirectory(folder/path);

// Then, remove the folder
FileUtils.deleteDirectory(folder/path);

Ou:

FileUtils.forceDelete(new File(destination));

Minha versão recursiva básica, trabalhando com versões mais antigas do JDK:

public static void deleteFile(File element) {
    if (element.isDirectory()) {
        for (File sub : element.listFiles()) {
            deleteFile(sub);
        }
    }
    element.delete();
}

Esta é a melhor solução para Java 7+:

public static void deleteDirectory(String directoryFilePath) throws IOException
{
    Path directory = Paths.get(directoryFilePath);

    if (Files.exists(directory))
    {
        Files.walkFileTree(directory, new SimpleFileVisitor<Path>()
        {
            @Override
            public FileVisitResult visitFile(Path path, BasicFileAttributes basicFileAttributes) throws IOException
            {
                Files.delete(path);
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path directory, IOException ioException) throws IOException
            {
                Files.delete(directory);
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

Goiaba 21+ para o resgate. Use apenas se não houver links simbólicos apontando para fora do diretório para exclusão.

com.google.common.io.MoreFiles.deleteRecursively(
      file.toPath(),
      RecursiveDeleteOption.ALLOW_INSECURE
) ;

(Esta pergunta foi bem indexada pelo Google, então outras pessoas que usem Guava podem ficar felizes em encontrar esta resposta, mesmo que seja redundante com outras respostas em outros lugares.)

Gosto mais desta solução. Não usa biblioteca de terceiros, em vez disso usa NIO2 de Java 7.

/**
 * Deletes Folder with all of its content
 *
 * @param folder path to folder which should be deleted
 */
public static void deleteFolderAndItsContent(final Path folder) throws IOException {
    Files.walkFileTree(folder, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
            Files.delete(file);
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
            if (exc != null) {
                throw exc;
            }
            Files.delete(dir);
            return FileVisitResult.CONTINUE;
        }
    });
}

Outra opção é usar o org.springframework.util.FileSystemUtilsmétodo relevante do Spring, que excluirá recursivamente todo o conteúdo do diretório.

File directoryToDelete = new File(<your_directory_path_to_delete>);
FileSystemUtils.deleteRecursively(directoryToDelete);

Isso fará o trabalho!

Nisso

index.delete();

            if (!index.exists())
               {
                   index.mkdir();
               }

você está ligando

 if (!index.exists())
                   {
                       index.mkdir();
                   }

depois de

index.delete();

Isso significa que você está criando o arquivo novamente após a exclusão de File.delete () retorna um valor booleano. Então, se você deseja verificar System.out.println(index.delete());se obtiver true, isso significa que o arquivo foi excluído

File index = new File("/home/Work/Indexer1");
    if (!index.exists())
       {
             index.mkdir();
       }
    else{
            System.out.println(index.delete());//If you get true then file is deleted




            if (!index.exists())
               {
                   index.mkdir();// here you are creating again after deleting the file
               }




        }

a partir dos comentários dados abaixo, a resposta atualizada é assim

File f=new File("full_path");//full path like c:/home/ri
    if(f.exists())
    {
        f.delete();
    }
    else
    {
        try {
            //f.createNewFile();//this will create a file
            f.mkdir();//this create a folder
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

Se você tiver subpastas, encontrará problemas com as respostas do Cemron. então você deve criar um método que funcione assim:

private void deleteTempFile(File tempFile) {
        try
        {
            if(tempFile.isDirectory()){
               File[] entries = tempFile.listFiles();
               for(File currentFile: entries){
                   deleteTempFile(currentFile);
               }
               tempFile.delete();
            }else{
               tempFile.delete();
            }
        getLogger().info("DELETED Temporal File: " + tempFile.getPath());
        }
        catch(Throwable t)
        {
            getLogger().error("Could not DELETE file: " + tempFile.getPath(), t);
        }
    }

Você pode usar FileUtils.deleteDirectory . JAVA não pode excluir as pastas não vazias com File.delete () .

O diretório não pode simplesmente deletar se ele tiver os arquivos, então você pode precisar deletar os arquivos dentro primeiro e depois o diretório

public class DeleteFileFolder {

public DeleteFileFolder(String path) {

    File file = new File(path);
    if(file.exists())
    {
        do{
            delete(file);
        }while(file.exists());
    }else
    {
        System.out.println("File or Folder not found : "+path);
    }

}
private void delete(File file)
{
    if(file.isDirectory())
    {
        String fileList[] = file.list();
        if(fileList.length == 0)
        {
            System.out.println("Deleting Directory : "+file.getPath());
            file.delete();
        }else
        {
            int size = fileList.length;
            for(int i = 0 ; i < size ; i++)
            {
                String fileName = fileList[i];
                System.out.println("File path : "+file.getPath()+" and name :"+fileName);
                String fullPath = file.getPath()+"/"+fileName;
                File fileOrFolder = new File(fullPath);
                System.out.println("Full Path :"+fileOrFolder.getPath());
                delete(fileOrFolder);
            }
        }
    }else
    {
        System.out.println("Deleting file : "+file.getPath());
        file.delete();
    }
}

Você pode fazer chamadas recursivas se houver subdiretórios

import java.io.File;

class DeleteDir {
public static void main(String args[]) {
deleteDirectory(new File(args[0]));
}

static public boolean deleteDirectory(File path) {
if( path.exists() ) {
  File[] files = path.listFiles();
  for(int i=0; i<files.length; i++) {
     if(files[i].isDirectory()) {
       deleteDirectory(files[i]);
     }
     else {
       files[i].delete();
     }
  }
}
return( path.delete() );
}
}

podemos usar a spring-coredependência;

boolean result = FileSystemUtils.deleteRecursively(file);

A maioria das respostas (mesmo recentes) que fazem referência a classes JDK dependem, File.delete()mas essa é uma API falha, pois a operação pode falhar silenciosamente.
A java.io.File.delete()documentação do método afirma:

Observe que a java.nio.file.Filesclasse define o deletemétodo para lançar um IOExceptionquando um arquivo não pode ser excluído. Isso é útil para relatórios de erros e para diagnosticar porque um arquivo não pode ser excluído.

Como substituto, você deve favorecer Files.delete(Path p) que lance umIOException com uma mensagem de erro.

O código real pode ser escrito como:

Path index = Paths.get("/home/Work/Indexer1");

if (!Files.exists(index)) {
    index = Files.createDirectories(index);
} else {

    Files.walk(index)
         .sorted(Comparator.reverseOrder())  // as the file tree is traversed depth-first and that deleted dirs have to be empty  
         .forEach(t -> {
             try {
                 Files.delete(t);
             } catch (IOException e) {
                 // LOG the exception and potentially stop the processing

             }
         });
    if (!Files.exists(index)) {
        index = Files.createDirectories(index);
    }
}

você pode tentar o seguinte

  File dir = new File("path");
   if (dir.isDirectory())
   {
         dir.delete();
   }

Se houver subpastas dentro da sua pasta, pode ser necessário excluí-las recursivamente.

private void deleteFileOrFolder(File file){
    try {
        for (File f : file.listFiles()) {
            f.delete();
            deleteFileOrFolder(f);
        }
    } catch (Exception e) {
        e.printStackTrace(System.err);
    }
}

        import org.apache.commons.io.FileUtils;

        List<String> directory =  new ArrayList(); 
        directory.add("test-output"); 
        directory.add("Reports/executions"); 
        directory.add("Reports/index.html"); 
        directory.add("Reports/report.properties"); 
        for(int count = 0 ; count < directory.size() ; count ++)
        {
        String destination = directory.get(count);
        deleteDirectory(destination);
        }





      public void deleteDirectory(String path) {

        File file  = new File(path);
        if(file.isDirectory()){
             System.out.println("Deleting Directory :" + path);
            try {
                FileUtils.deleteDirectory(new File(path)); //deletes the whole folder
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        else {
        System.out.println("Deleting File :" + path);
            //it is a simple file. Proceed for deletion
            file.delete();
        }

    }

Funciona como um encanto . Para pastas e arquivos. Salam :)

Remova-o de outra parte

File index = new File("/home/Work/Indexer1");
if (!index.exists())
{
     index.mkdir();
     System.out.println("Dir Not present. Creating new one!");
}
index.delete();
System.out.println("File deleted successfully");

Algumas dessas respostas parecem desnecessariamente longas:

if (directory.exists()) {
    for (File file : directory.listFiles()) {
        file.delete();
    }
    directory.delete();
}

Funciona para subdiretórios também.

Você pode usar esta função

public void delete()    
{   
    File f = new File("E://implementation1/");
    File[] files = f.listFiles();
    for (File file : files) {
        file.delete();
    }
}