Удалить каталоги рекурсивно в 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. (я не считаю Апач Викисклада ИО иметь надежное обнаружение символьной ссылки в это время, так как он не обрабатывает ссылки на 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

Может быть, решение этой проблемы может быть переописать удаления метод класса File, используя код от ответа Эриксона:

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 4

Вот основной метод голые кости, которая принимает аргумент командной строки, вам может понадобиться, чтобы добавить свою собственную проверку ошибок или форму его, как вы считаете нужным.

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 5

Guava был Files.deleteRecursively(File) был поддержан до Guava 9.

От Guava 10:

устар. Этот метод страдает от плохой идентификации и условий гонки. Эта функциональность может поддерживаться соответствующим образом только путем обхода команды операционной системы, такой как rm -rf или del /s. Этот способ планируется удалить из Guava в выпуске версии Guava 11.0.

Следовательно, такого метода нет в Guava 11.

Answer 6

Просто увидел, что мое решение более или менее такое же, как у erickson's, только что упакованное как статический метод. Бросьте это где-нибудь, это намного легче, чем устанавливать все 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 7

Два способа отказа с символическими ссылками и приведенный выше код ... и не знают решения.

Way # 1

Выполнить это, чтобы создать тест:

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

Здесь вы видите файл теста и тестовый каталог:

$ ls testfile dirtodelete 
testfile 

dirtodelete: 
linktodelete

затем запустить Обще-ю deleteDirectory (). Он падает, говоря, что файл не найден. Не знаете, что здесь делают другие примеры. Команда Linux rm просто удалит ссылку, а также rm -r в каталоге.

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

Way # 2

Выполнить это, чтобы создать тест:

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

Здесь вы видите файл теста и тестовый каталог:

$ ls dirtodelete testdir 
dirtodelete: 
dirlinktodelete 

testdir: 
testfile 

Затем запустить свой commons- io deleteDirectory() или примеры кода, опубликованные пользователем. Он удаляет не только каталог, но и ваш тестовый файл, который находится за пределами удаляемого каталога. (Он разыменовывает каталог неявно и удаляет содержимое). rm -r удалит только ссылку. Вам нужно использовать что-то вроде этого, удаляя разыменованные файлы: «find -L dirtodelete -type f -exec rm {} \;".

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

Answer 8

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 9

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 10

Java 7 добавлена ​​поддержка для ходьбы каталогов с обработкой SYMLINK:

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 11

Раствор со стеком и без рекурсивных методов:.

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 12

Вы могли бы использовать:

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

Удаляет файл, никогда не бросая исключение. Если файл является каталогом, удалите его и все подкаталоги. Разница между File.delete() и этим методом: Удаляемый каталог не должен быть пустым. Исключения не исключаются, если невозможно удалить файл или каталог.

Answer 13

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 14

В 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 15

Если у вас есть весна, вы можете использовать FileSystemUtils.deleteRecursively:

import org.springframework.util.FileSystemUtils; 

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

Answer 16

Хотя файлы могут быть легко удалены с помощью 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 17

Без 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 18

В старых проектах, нужно создать собственный код 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 19

раствор Однострочник (Java8) удалить все файлы и каталоги рекурсивно, включая начиная каталог:

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

Мы используйте компаратор для обратного порядка, иначе File :: delete не сможет удалить, возможно, непустой каталог. Таким образом, если вы хотите сохранить каталоги и удалять только файлы, просто удалите компаратор отсортировано() или удалить сортировку полностью и добавить файлы фильтр:

Files.walk(Paths.get("c:/dir_to_delete/")) 
       .filter(Files::isRegularFile) 
       .map(Path::toFile) 
       .forEach(File::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); 
    } 
} 

Answer 21

Ну, давайте предположим, что пример,

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 22

оптимальное решение, который обрабатывает исключение в соответствии с подходом, что исключение брошенной из метода всегда должен описывать, что этот метод пытался (и не удалось):

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 23

Ниже код рекурсивно удаляет все содержимое в данной папке.

boolean deleteDirectory(File directoryToBeDeleted) { 
    File[] allContents = directoryToBeDeleted.listFiles(); 
    if (allContents != null) { 
     for (File file : allContents) { 
      deleteDirectory(file); 
     } 
    } 
    return directoryToBeDeleted.delete(); 
}