Verzeichnisse rekursiv löschen in Java

Question

Gibt es eine Möglichkeit, in Java ganze Verzeichnisse rekursiv zu löschen?

Im Normalfall ist es möglich, ein leeres Verzeichnis zu löschen. Wenn es jedoch darum geht, ganze Verzeichnisse mit Inhalt zu löschen, ist das nicht mehr so einfach.

Wie kann man in Java ganze Verzeichnisse mit Inhalt löschen?

Answer 1

Guave bietet einen Einzeiler: MoreFiles.deleteRecursively() .

Im Gegensatz zu vielen anderen Beispielen berücksichtigt es symbolische Links und löscht (standardmäßig) keine Dateien außerhalb des angegebenen Pfads.

Answer 2

Bei älteren Projekten muss ich nativen Java-Code erstellen. Ich erstelle diesen Code ähnlich wie den Paulitex-Code. Siehe das:

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

Und der Einheitstest:

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 3

Untenstehender Code löscht rekursiv alle Inhalte in einem bestimmten Ordner.

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

Answer 4

Hier ist eine einfache Hauptmethode, die ein Kommandozeilenargument akzeptiert. Sie müssen möglicherweise Ihre eigene Fehlerprüfung hinzufügen oder sie so gestalten, wie Sie es für richtig halten.

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

Ich hoffe, das hilft!

Answer 5

// Java 8 mit lambda & stream, wenn param ein Verzeichnis ist

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

// wenn param eine Datei oder ein Verzeichnis ist

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