在Java中recursion地删除目录

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

在正常情况下，可以删除一个空目录。 但是，当用内容删除整个目录时，就不那么简单了。

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

Answer 1

你应该看看Apache的commons-io 。 它有一个FileUtils类，将做你想做的。

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

Answer 2

使用Java 7，我们终于可以通过可靠的符号链接检测来做到这一点。 （我不认为Apache的commons-io此时有可靠的符号链接检测，因为它不处理用mklink创build的Windows上的mklink 。）

为了历史的缘故，这是一个Java之前的答案，它遵循符号链接。

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

我将其用作平台特定方法的回退（在这个未经testing的代码中）：

 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

刚刚看到我的解决scheme与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 && FileUtils.deleteRecursive(f); } } return ret && path.delete(); } } 

Answer 6

单线程解决scheme（Java8）以recursion方式删除所有文件和目录，包括起始目录：

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

我们使用反向比较器，否则File :: delete将无法删除可能的非空目录。 所以，如果你想保留目录，只删除文件，只需在sorted（）中删除比较器或完全删除sorting，并添加文件filter：

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

Answer 7

一个堆栈和没有recursion方法的解决scheme：

 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

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

从番石榴10 ：

已过时。 这种方法遇到糟糕的符号链接检测和竞争条件。 这个function只有通过脱壳到一个操作系统命令（如rm -rf或del /s才能被支持。 这种方法计划从Guava版本11.0中的Guava中移除。

因此，在番石榴11中没有这样的方法。

Answer 9

 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 10

 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 11

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

 import org.springframework.util.FileSystemUtils; boolean success = FileSystemUtils.deleteRecursively(new File("directory")); 

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

两种方法失败，符号链接和上面的代码…并不知道解决scheme。

方式＃1

运行这个来创build一个testing：

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

在这里你可以看到你的testing文件和testing目录：

 $ ls testfile dirtodelete testfile dirtodelete: linktodelete 

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

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

方式2

运行这个来创build一个testing：

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

在这里你可以看到你的testing文件和testing目录：

 $ 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 14

你可以使用：

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

删除一个文件，永远不会抛出一个exception。 如果文件是一个目录，删除它和所有的子目录。 File.delete（）和此方法之间的区别是：要删除的目录不一定是空的。 无法删除文件或目录时，不会引发exception。

Answer 15

在遗留项目中，我需要创build本地Java代码。 我创build了类似于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; } } 

而unit testing：

 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 16

这里是接受命令行参数的一个简单的主要方法，你可能需要附加你自己的错误检查或模拟它，以适应你的看法。

 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 17

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

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

Answer 18

尽pipe可以使用file.delete（）轻松删除文件，但是需要将目录清空才能删除。 使用recursion来做到这一点很容易。 例如：

 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 19

没有Commons IO和<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

我编写了这个程序，有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); } }