从java中删除文件夹

Question

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

    }

}

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

Answer 1

如果您使用 Apache Commons IO，那么它只是一句：

FileUtils.deleteDirectory(dir);

请参阅 FileUtils.deleteDirectory()

---

Guava 用于支持类似功能：

Files.deleteRecursively(dir);

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

---

虽然上面的版本非常简单，但它也非常危险，因为它在没有告诉你的情况下做出了很多假设。因此，虽然在大多数情况下它可能是安全的，但我更喜欢“官方方式”来执行此操作（从 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;
    }
  });
};

Answer 2

我有这样的东西：

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

Answer 3

试试这个：

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

Answer 4

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

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

Answer 5

我发现这段代码更容易理解并且更有效：

public static boolean deleteDir(File dir) {
    if (dir.isDirectory()) {
        String[] children = dir.list();
        for (int i = 0; i < children.length; i++) {
            boolean success = deleteDir(new File(dir, children[i]));
            if (!success) {
                return false;
            }
        }
    }

    return dir.delete(); // The directory is empty now and can be deleted.
}

Answer 6

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

检查这个问题

Answer 7

我之前为此写了一个方法。删除指定目录，如果目录删除成功则返回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();
}

Answer 8

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

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

Answer 9

文件的 javadoc .delete()

公共布尔删除()

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

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

将这些行更改

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

为此

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

应该会导致您的代码首先删除子文件夹。

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

Answer 10

你应该先删除文件夹中的文件，然后删除文件夹。这样你就会递归地调用该方法。

Answer 11

它将递归删除文件夹

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