从java中删除文件夹

deleting folder from java

提问by M.J.

In Java, I want to delete all the contents that are present in a folder which includes files and folders.

在 Java 中，我想删除包含文件和文件夹的文件夹中存在的所有内容。

public void startDeleting(String path) {
        List<String> filesList = new ArrayList<String>();
        List<String> folderList = new ArrayList<String>();
        fetchCompleteList(filesList, folderList, path);
        for(String filePath : filesList) {
            File tempFile = new File(filePath);
            tempFile.delete();
        }
        for(String filePath : folderList) {
            File tempFile = new File(filePath);
            tempFile.delete();
        }
    }

private void fetchCompleteList(List<String> filesList, 
    List<String> folderList, String path) {
    File file = new File(path);
    File[] listOfFile = file.listFiles();
    for(File tempFile : listOfFile) {
        if(tempFile.isDirectory()) {
            folderList.add(tempFile.getAbsolutePath());
            fetchCompleteList(filesList, 
                folderList, tempFile.getAbsolutePath());
        } else {
            filesList.add(tempFile.getAbsolutePath());
        }

    }

}

This code does not work, what is the best way to do this?

此代码不起作用，执行此操作的最佳方法是什么？

采纳答案by Sean Patrick Floyd

If you use Apache Commons IOit's a one-liner:

如果您使用Apache Commons IO，则它是单行的：

FileUtils.deleteDirectory(dir);

See FileUtils.deleteDirectory()

参见FileUtils.deleteDirectory()

---

---

Guavaused to support similar functionality:

Guava曾经支持类似的功能：

Files.deleteRecursively(dir);

Files.deleteRecursively(dir);

This has been removed from Guava several releases ago.

这已在几个版本前从 Guava 中删除。

---

---

While the above version is very simple, it is also pretty dangerous, as it makes a lot of assumptions without telling you. So while it may be safe in most cases, I prefer the "official way" to do it (since Java 7):

虽然上面的版本很简单，但它也很危险，因为它在没有告诉你的情况下做了很多假设。因此，虽然在大多数情况下它可能是安全的，但我更喜欢“官方方式”来做到这一点（从 Java 7 开始）：

public static void deleteFileOrFolder(final Path path) throws IOException {
  Files.walkFileTree(path, new SimpleFileVisitor<Path>(){
    @Override public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs)
      throws IOException {
      Files.delete(file);
      return CONTINUE;
    }

    @Override public FileVisitResult visitFileFailed(final Path file, final IOException e) {
      return handleException(e);
    }

    private FileVisitResult handleException(final IOException e) {
      e.printStackTrace(); // replace with more robust error handling
      return TERMINATE;
    }

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

回答by oyo

I have something like this :

我有这样的事情：

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

回答by Sidharth Panwar

Try this:

尝试这个：

public static boolean deleteDir(File dir) 
{ 
  if (dir.isDirectory()) 
  { 
    String[] children = dir.list(); 
    for (int i=0; i<children.length; i++)
      return deleteDir(new File(dir, children[i])); 
  }  
  // The directory is now empty or this is a file so delete it 
  return dir.delete(); 
} 

回答by Thilo

It could be problem with nested folders. Your code deletes the folders in the order they were found, which is top-down, which does not work. It might work if you reverse the folder list first.

嵌套文件夹可能有问题。您的代码按照找到的顺序删除文件夹，这是自上而下的，这是行不通的。如果您先反转文件夹列表，它可能会起作用。

But I would recommend you just use a library like Commons IO for this.

但是我建议您为此使用像 Commons IO 这样的库。

回答by Andreas Dolk

You're storing all (sub-) files and folder recursively in a list, but with your current code you store the parent folder beforeyou store the children. And so you try to delete the folder before it is empty. Try this code:

您将所有（子）文件和文件夹以递归方式存储在列表中，但使用当前代码，您可以在存储子文件夹之前存储父文件夹。因此，您尝试在该文件夹为空之前将其删除。试试这个代码：

   if(tempFile.isDirectory()) {
        // children first
        fetchCompleteList(filesList, folderList, tempFile.getAbsolutePath());
        // parent folder last
        folderList.add(tempFile.getAbsolutePath());
   }

回答by josefx

The javadoc for File.delete()

File.delete()的 javadoc

public boolean delete()

Deletes the file or directory denoted by this abstract pathname. If this pathname >denotes a directory, then the directory must be empty in order to be deleted.

公共布尔删除（）

删除此抽象路径名表示的文件或目录。如果此路径名 > 表示一个目录，则该目录必须为空才能被删除。

So a folder has to be empty or deleting it will fail. Your code currently fills the folder list with the top most folder first, followed by its sub folders. Since you iterrate through the list in the same way it will try to delete the top most folder before deleting its subfolders, this will fail.

所以文件夹必须是空的，否则删除它会失败。您的代码当前首先使用最顶部的文件夹填充文件夹列表，然后是其子文件夹。由于您以相同的方式遍历列表，它会在删除其子文件夹之前尝试删除最顶层的文件夹，因此这将失败。

Changing these line

改变这些线

    for(String filePath : folderList) {
        File tempFile = new File(filePath);
        tempFile.delete();
    }

to this

对此

    for(int i = folderList.size()-1;i>=0;i--) {
        File tempFile = new File(folderList.get(i));
        tempFile.delete();
    }

should cause your code to delete the sub folders first.

应该使您的代码首先删除子文件夹。

The delete operation also returns false when it fails, so you can check this value to do some error handling if necessary.

删除操作在失败时也会返回 false，因此您可以在必要时检查此值以进行一些错误处理。

回答by naikus

I wrote a method for this sometime back. It deletes the specified directory and returns true if the directory deletion was successful.

我曾经为此写了一个方法。它删除指定的目录，如果目录删除成功则返回 true。

/**
 * Delets a dir recursively deleting anything inside it.
 * @param dir The dir to delete
 * @return true if the dir was successfully deleted
 */
public static boolean deleteDirectory(File dir) {
    if(! dir.exists() || !dir.isDirectory())    {
        return false;
    }

    String[] files = dir.list();
    for(int i = 0, len = files.length; i < len; i++)    {
        File f = new File(dir, files[i]);
        if(f.isDirectory()) {
            deleteDirectory(f);
        }else   {
            f.delete();
        }
    }
    return dir.delete();
}

回答by ahvargas

Using the FileUtils.deleteDirectory()method can help to simplify the process of deleting directory and everything below it recursively.

使用FileUtils.deleteDirectory()方法可以帮助简化递归删除目录及其下面所有内容的过程。

Check thisquestion

检查这个问题

回答by Dead Programmer

You should delete the file in the folder first , then the folder.This way you will recursively call the method.

您应该先删除文件夹中的文件，然后再删除文件夹。这样您将递归调用该方法。

回答by Rishabh

It will delete a folder recursively

它将递归删除文件夹

public static void folderdel(String path){
    File f= new File(path);
    if(f.exists()){
        String[] list= f.list();
        if(list.length==0){
            if(f.delete()){
                System.out.println("folder deleted");
                return;
            }
        }
        else {
            for(int i=0; i<list.length ;i++){
                File f1= new File(path+"\"+list[i]);
                if(f1.isFile()&& f1.exists()){
                    f1.delete();
                }
                if(f1.isDirectory()){
                    folderdel(""+f1);
                }
            }
            folderdel(path);
        }
    }
}