在Java中递归删除目录

Question

有没有办法在Java中递归删除整个目录？

在正常情况下，可以删除空目录。 但是，当要删除包含内容的整个目录时，它就不再那么简单了。

如何使用Java中的内容删除整个目录？

Answer 1

你应该看看Apache's commons-io。它有一个FileUtils类，可以做你想做的事。

FileUtils.deleteDirectory(new File("directory"));

Answer 2

使用Java 7，我们最终可以do this with reliable symlink detection.（我不认为Apache的commons-io目前有可靠的符号链接检测，因为它不处理Windows上的链接使用mklink创建。）

为了历史，这里是一个Java 7之前的答案，其中遵循符号链接。

void delete(File f) throws IOException {
  if (f.isDirectory()) {
    for (File c : f.listFiles())
      delete(c);
  }
  if (!f.delete())
    throw new FileNotFoundException("Failed to delete file: " + f);
}

Answer 3

在Java 7+中，您可以使用Files类。代码很简单：

Path directory = Paths.get("/tmp");
Files.walkFileTree(directory, 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 {
       Files.delete(dir);
       return FileVisitResult.CONTINUE;
   }
});

Answer 4

Java 7增加了对使用符号链接处理的步行目录的支持：

import java.nio.file.*;

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

        @Override
        public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException
        {
            // try to delete the file anyway, even if its attributes
            // could not be read, since delete-only access is
            // theoretically possible
            Files.delete(file);
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException
        {
            if (exc == null)
            {
                Files.delete(dir);
                return FileVisitResult.CONTINUE;
            }
            else
            {
                // directory iteration failed; propagate exception
                throw exc;
            }
        }
    });
}

我将此作为平台特定方法的后备（在此未经测试的代码中）：

public static void removeDirectory(Path directory) throws IOException
{
    // does nothing if non-existent
    if (Files.exists(directory))
    {
        try
        {
            // prefer OS-dependent directory removal tool
            if (SystemUtils.IS_OS_WINDOWS)
                Processes.execute("%ComSpec%", "/C", "RD /S /Q \"" + directory + '"');
            else if (SystemUtils.IS_OS_UNIX)
                Processes.execute("/bin/rm", "-rf", directory.toString());
        }
        catch (ProcessExecutionException | InterruptedException e)
        {
            // fallback to internal implementation on error
        }

        if (Files.exists(directory))
            removeRecursive(directory);
    }
}

（SystemUtils来自Apache Commons Lang。进程是私有的，但其行为应该是显而易见的。）

Answer 5

单行解决方案（Java8）以递归方式删除所有文件和目录，包括起始目录：

Files.walk(Paths.get("c:/dir_to_delete/"))
                .map(Path::toFile)
                .sorted((o1, o2) -> -o1.compareTo(o2))
                .forEach(File::delete);

我们使用比较器来反转顺序，否则File :: delete不能删除可能非空的目录。因此，如果您想保留目录并且只删除文件，只需删除sorted（）或中的比较器，完全删除排序并添加文件过滤器：

Files.walk(Paths.get("c:/dir_to_delete/"))
                .filter(Files::isRegularFile)
                .map(Path::toFile)
                .forEach(File::delete);

Answer 6

刚看到我的解决方案与erickson的解决方案大致相同，只是打包为静态方法。把它放在某个地方，它比安装所有Apache Commons的重量要轻得多（如你所见）非常简单。

public class FileUtils {
    /**
     * By default File#delete fails for non-empty directories, it works like "rm". 
     * We need something a little more brutual - this does the equivalent of "rm -r"
     * @param path Root File Path
     * @return true iff the file and all sub files/directories have been removed
     * @throws FileNotFoundException
     */
    public static boolean deleteRecursive(File path) throws FileNotFoundException{
        if (!path.exists()) throw new FileNotFoundException(path.getAbsolutePath());
        boolean ret = true;
        if (path.isDirectory()){
            for (File f : path.listFiles()){
                ret = ret && deleteRecursive(f);
            }
        }
        return ret && path.delete();
    }
}

Answer 7

具有堆栈且没有递归方法的解决方案：

File dir = new File("/path/to/dir");
File[] currList;
Stack<File> stack = new Stack<File>();
stack.push(dir);
while (! stack.isEmpty()) {
    if (stack.lastElement().isDirectory()) {
        currList = stack.lastElement().listFiles();
        if (currList.length > 0) {
            for (File curr: currList) {
                stack.push(curr);
            }
        } else {
            stack.pop().delete();
        }
    } else {
        stack.pop().delete();
    }
}

Answer 8

Guava支持Files.deleteRecursively(File)，直到番石榴9 。

来自Guava 10：

  

已弃用。此方法的符号链接检测和竞争条件较差。仅通过外壳到诸如rm -rf或del /s的操作系统命令，可以适当地支持此功能。 此方法计划在Guava版本11.0中从Guava中删除。

因此，Guava 11中没有这样的方法。

Answer 9

如果您有Spring，可以使用FileSystemUtils.deleteRecursively：

import org.springframework.util.FileSystemUtils;

boolean success = FileSystemUtils.deleteRecursively(new File("directory"));

Answer 10

for(Path p : Files.walk(directoryToDelete).
        sorted((a, b) -> b.compareTo(a)). // reverse; files before dirs
        toArray(Path[]::new))
{
    Files.delete(p);
}

或者，如果您想处理IOException：

Files.walk(directoryToDelete).
    sorted((a, b) -> b.compareTo(a)). // reverse; files before dirs
    forEach(p -> {
        try { Files.delete(p); }
        catch(IOException e) { /* ... */ }
      });

Answer 11

public void deleteRecursive(File path){
    File[] c = path.listFiles();
    System.out.println("Cleaning out folder:" + path.toString());
    for (File file : c){
        if (file.isDirectory()){
            System.out.println("Deleting file:" + file.toString());
            deleteRecursive(file);
            file.delete();
        } else {
            file.delete();
        }
    }
    path.delete();
}

Answer 12

static public void deleteDirectory(File path) 
{
    if (path == null)
        return;
    if (path.exists())
    {
        for(File f : path.listFiles())
        {
            if(f.isDirectory()) 
            {
                deleteDirectory(f);
                f.delete();
            }
            else
            {
                f.delete();
            }
        }
        path.delete();
    }
}

Answer 13

一种处理异常的最佳解决方案，方法是从方法抛出的异常应始终描述该方法尝试（和失败）的方法：

private void deleteRecursive(File f) throws Exception {
    try {
        if (f.isDirectory()) {
            for (File c : f.listFiles()) {
                deleteRecursive(c);
            }
        }
        if (!f.delete()) {
            throw new Exception("Delete command returned false for file: " + f);
        }
    } 
    catch (Exception e) {
        throw new Exception("Failed to delete the folder: " + f, e);
    }
}

Answer 14

使用符号链接和上述代码失败的两种方法......并且不知道解决方案。

方式＃1

运行此命令以创建测试：

echo test > testfile
mkdir dirtodelete
ln -s badlink dirtodelete/badlinktodelete

在这里，您可以看到您的测试文件和测试目录：

$ ls testfile dirtodelete
testfile

dirtodelete:
linktodelete

然后运行你的commons-io deleteDirectory（）。它崩溃说没有找到该文件。不知道其他例子在这里做了什么。 Linux rm命令只会删除链接，目录上的rm -r也会。

Exception in thread "main" java.io.FileNotFoundException: File does not exist: /tmp/dirtodelete/linktodelete

方式＃2

运行此命令以创建测试：

mkdir testdir
echo test > testdir/testfile
mkdir dirtodelete
ln -s ../testdir dirtodelete/dirlinktodelete

在这里，您可以看到您的测试文件和测试目录：

$ ls dirtodelete testdir
dirtodelete:
dirlinktodelete

testdir:
testfile

然后运行你的commons-io deleteDirectory（）或发布的示例代码。它不仅会删除目录，还会删除要删除的目录之外的testfile。 （它隐式取消引用目录，并删除内容）。 rm -r只会删除链接。你需要使用这样的东西删除解​​除引用的文件：“find -L dirtodelete -t​​ype f -exec rm {} \;”。

$ ls dirtodelete testdir
ls: cannot access dirtodelete: No such file or directory
testdir:

Answer 15

您可以使用：

org.apache.commons.io.FileUtils.deleteQuietly(destFile);

删除文件，永不抛出异常。如果file是目录，则删除它和所有子目录。 File.delete（）和此方法之间的区别是： 要删除的目录不必为空。 如果无法删除文件或目录，则不会引发异常。

Answer 16

在旧项目中，我需要创建本机Java代码。我创建类似于Paulitex代码的代码。见：

public class FileHelper {

   public static boolean delete(File fileOrFolder) {
      boolean result = true;
      if(fileOrFolder.isDirectory()) {
         for (File file : fileOrFolder.listFiles()) {
            result = result && delete(file);
         }
      }
      result = result && fileOrFolder.delete();
      return result;
   } 
}

单元测试：

public class FileHelperTest {

    @Before
    public void setup() throws IOException {
       new File("FOLDER_TO_DELETE/SUBFOLDER").mkdirs();
       new File("FOLDER_TO_DELETE/SUBFOLDER_TWO").mkdirs();
       new File("FOLDER_TO_DELETE/SUBFOLDER_TWO/TEST_FILE.txt").createNewFile();
    }

    @Test
    public void deleteFolderWithFiles() {
       File folderToDelete = new File("FOLDER_TO_DELETE");
       Assert.assertTrue(FileHelper.delete(folderToDelete));
       Assert.assertFalse(new File("FOLDER_TO_DELETE").exists());
    }

}

Answer 17

Guava提供了一个单行代码：MoreFiles.deleteRecursively()。

与共享的许多示例不同，它说明了符号链接，并且（默认情况下）不会删除提供的路径之外的文件。

Answer 18

下面的代码以递归方式删除给定文件夹中的所有内容。

Dim _Flags As TextFormatFlags
If Me.TextAlign = ContentAlignment.BottomCenter Then
    _Flags = TextFormatFlags.Bottom Or TextFormatFlags.HorizontalCenter
ElseIf Me.TextAlign = ContentAlignment.BottomLeft Then
    _Flags = TextFormatFlags.Bottom Or TextFormatFlags.Left
ElseIf Me.TextAlign = ContentAlignment.BottomRight Then
    _Flags = TextFormatFlags.Bottom Or TextFormatFlags.Right
ElseIf Me.TextAlign = ContentAlignment.MiddleCenter Then
    _Flags = TextFormatFlags.VerticalCenter Or TextFormatFlags.HorizontalCenter
ElseIf Me.TextAlign = ContentAlignment.MiddleLeft Then
    _Flags = TextFormatFlags.VerticalCenter Or TextFormatFlags.Left
ElseIf Me.TextAlign = ContentAlignment.MiddleRight Then
    _Flags = TextFormatFlags.VerticalCenter Or TextFormatFlags.Right
ElseIf Me.TextAlign = ContentAlignment.TopCenter Then
    _Flags = TextFormatFlags.Top Or TextFormatFlags.HorizontalCenter
ElseIf Me.TextAlign = ContentAlignment.TopLeft Then
    _Flags = TextFormatFlags.Top Or TextFormatFlags.Left
ElseIf Me.TextAlign = ContentAlignment.TopRight Then
    _Flags = TextFormatFlags.Top Or TextFormatFlags.Right
End If
TextRenderer.DrawText(e.Graphics, e.ToolTipText, Me.Font, e.Bounds, Me.ForeColor, Me.BackColor, _Flags)
e.Graphics.Dispose()

Answer 19

没有Commons IO和＆lt; Java SE 7

public static void deleteRecursive(File path){
            path.listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    if (pathname.isDirectory()) {
                        pathname.listFiles(this);
                        pathname.delete();
                    } else {
                        pathname.delete();
                    }
                    return false;
                }
            });
            path.delete();
        }

Answer 20

这是一个接受命令行参数的裸骨主要方法，您可能需要附加自己的错误检查或将其塑造成您认为合适的方式。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;

public class DeleteFiles {

/**
 * @param intitial arguments take in a source to read from and a 
 * destination to read to
 */
    public static void main(String[] args)
                     throws FileNotFoundException,IOException {
        File src = new File(args[0]);
        if (!src.exists() ) {
            System.out.println("FAILURE!");
        }else{
            // Gathers files in directory
            File[] a = src.listFiles();
            for (int i = 0; i < a.length; i++) {
                //Sends files to recursive deletion method
                fileDelete(a[i]);
            }
            // Deletes original source folder
            src.delete();
            System.out.println("Success!");
        }
    }

    /**
     * @param srcFile Source file to examine
     * @throws FileNotFoundException if File not found
     * @throws IOException if File not found
     */
    private static void fileDelete(File srcFile)
                     throws FileNotFoundException, IOException {
        // Checks if file is a directory
        if (srcFile.isDirectory()) {
            //Gathers files in directory
            File[] b = srcFile.listFiles();
            for (int i = 0; i < b.length; i++) {
                //Recursively deletes all files and sub-directories
                fileDelete(b[i]);
            }
            // Deletes original sub-directory file
            srcFile.delete();
        } else {
            srcFile.delete();
        }
    }
}

我希望有所帮助！

Answer 21

//具有lambda和流的Java 8，如果参数是目录

static boolean delRecursive(File dir) {
    return Arrays.stream(dir.listFiles()).allMatch((f) -> f.isDirectory() ? delRecursive(f) : f.delete()) && dir.delete();
}

//如果参数是文件或目录

static boolean delRecursive(File fileOrDir) {
    return fileOrDir.isDirectory() ? Arrays.stream(fileOrDir.listFiles()).allMatch((f) -> delRecursive(f)) && fileOrDir.delete() : fileOrDir.delete();
}

Answer 22

番石榴 21.0 及更高版本

自 Guava 21.0 起，就提供了 void deleteRecursively(Path path, RecursiveDeleteOption... options) throws IOException 类的 MoreFiles 静态方法。

请参阅Javadoc documentation：

<块引用>

public static void deleteRecursively(Path path, RecursiveDeleteOption...选项） 抛出IOException

递归删除给定 path 处的文件或目录。删除符号链接，而不是它们的目标（须遵守以下警告）。

如果在尝试读取、打开或删除给定目录下的任何文件时发生 I/O 异常，此方法将跳过该文件并继续。收集所有此类异常，并在尝试删除所有文件后抛出 IOException，其中包含这些异常为 suppressed exceptions。

Answer 23

rm -rf的性能要比FileUtils.deleteDirectory高。

经过广泛的基准测试，我们发现使用rm -rf的速度是使用FileUtils.deleteDirectory的速度的几倍。

当然，如果您的目录很小或简单，那都没关系，但是在我们的例子中，我们有多个千兆字节和深层嵌套的子目录，其中FileUtils.deleteDirectory会花费10分钟以上，而只有1分钟与rm -rf。

这是我们的粗略Java实现：

// Delete directory given and all subdirectories and files (i.e. recursively).
//
static public boolean deleteDirectory( File file ) throws IOException, InterruptedException {

    if ( file.exists() ) {

        String deleteCommand = "rm -rf " + file.getAbsolutePath();
        Runtime runtime = Runtime.getRuntime();

        Process process = runtime.exec( deleteCommand );
        process.waitFor();

        return true;
    }

    return false;

}

如果要处理大型或复杂目录，则值得尝试。

Answer 24

好吧，我们假设一个例子，

import java.io.File;
import java.io.IOException;

public class DeleteDirectory
{
   private static final String folder = "D:/project/java";

   public static void main(String[] args) throws IOException
   {
      File fl = new File(folder);
      if(!fl.exists()) // checking if directory exists
      {
         System.out.println("Sorry!! directory doesn't exist.");
      }
      else
      {
         DeleteDirectory dd = new DeleteDirectory();
         dd.deleteDirectory(fl);
      }
   }

   public void deleteDirectory(File file) throws IOException
   {
      if(file.isDirectory())
      {
         if(file.list().length == 0)
         { 
            deleteEmptyDirectory(file); // here if directory is empty delete we are deleting
         }
         else
         {
            File fe[] = file.listFiles();
            for(File deleteFile : fe)
            {
               deleteDirectory(deleteFile); // recursive call
            }
            if(file.list().length == 0)
            {
               deleteEmptyDirectory(file);
            }
         }
      }
      else
      {
         file.delete();
         System.out.println("File deleted : " + file.getAbsolutePath());
      }
   }

   private void deleteEmptyDirectory(File fi)
   {
      fi.delete();
      System.out.println("Directory deleted : " + fi.getAbsolutePath());
   }
}

有关更多信息，请参阅以下资源

Delete directory

Answer 25

我编写了这个例程，该例程有3个安全标准，可以更安全地使用。

package ch.ethz.idsc.queuey.util;

import java.io.File;
import java.io.IOException;

/** recursive file/directory deletion
 * 
 * safety from erroneous use is enhanced by three criteria
 * 1) checking the depth of the directory tree T to be deleted
 * against a permitted upper bound "max_depth"
 * 2) checking the number of files to be deleted #F
 * against a permitted upper bound "max_count"
 * 3) if deletion of a file or directory fails, the process aborts */
public final class FileDelete {
    /** Example: The command
     * FileDelete.of(new File("/user/name/myapp/recordings/log20171024"), 2, 1000);
     * deletes given directory with sub directories of depth of at most 2,
     * and max number of total files less than 1000. No files are deleted
     * if directory tree exceeds 2, or total of files exceed 1000.
     * 
     * abort criteria are described at top of class
     * 
     * @param file
     * @param max_depth
     * @param max_count
     * @return
     * @throws Exception if criteria are not met */
    public static FileDelete of(File file, int max_depth, int max_count) throws IOException {
        return new FileDelete(file, max_depth, max_count);
    }

    // ---
    private final File root;
    private final int max_depth;
    private int removed = 0;

    /** @param root file or a directory. If root is a file, the file will be deleted.
     *            If root is a directory, the directory tree will be deleted.
     * @param max_depth of directory visitor
     * @param max_count of files to delete
     * @throws IOException */
    private FileDelete(final File root, final int max_depth, final int max_count) throws IOException {
        this.root = root;
        this.max_depth = max_depth;
        // ---
        final int count = visitRecursively(root, 0, false);
        if (count <= max_count) // abort criteria 2)
            visitRecursively(root, 0, true);
        else
            throw new IOException("more files to be deleted than allowed (" + max_count + "<=" + count + ") in " + root);
    }

    private int visitRecursively(final File file, final int depth, final boolean delete) throws IOException {
        if (max_depth < depth) // enforce depth limit, abort criteria 1)
            throw new IOException("directory tree exceeds permitted depth");
        // ---
        int count = 0;
        if (file.isDirectory()) // if file is a directory, recur
            for (File entry : file.listFiles())
                count += visitRecursively(entry, depth + 1, delete);
        ++count; // count file as visited
        if (delete) {
            final boolean deleted = file.delete();
            if (!deleted) // abort criteria 3)
                throw new IOException("cannot delete " + file.getAbsolutePath());
            ++removed;
        }
        return count;
    }

    public int deletedCount() {
        return removed;
    }

    public void printNotification() {
        int count = deletedCount();
        if (0 < count)
            System.out.println("deleted " + count + " file(s) in " + root);
    }
}

Answer 26

虽然可以使用file.delete（）轻松删除文件，但目录必须为空才能删除。使用递归来轻松完成此操作。例如：

public static void clearFolders(String[] args) {
        for(String st : args){
            File folder = new File(st);
            if (folder.isDirectory()) {
                File[] files = folder.listFiles();
                if(files!=null) { 
                    for(File f: files) {
                        if (f.isDirectory()){
                            clearFolders(new String[]{f.getAbsolutePath()});
                            f.delete();
                        } else {
                            f.delete();
                        }
                    }
                }
            }
        }
    }

Answer 27

也许这个问题的解决方案可能是使用erickson的答案中的代码重新实现File类的delete方法：

public class MyFile extends File {

  ... <- copy constructor

  public boolean delete() {
    if (f.isDirectory()) {
      for (File c : f.listFiles()) {
        return new MyFile(c).delete();
      }
    } else {
        return f.delete();
    }
  }
}