So löschen Sie einen Ordner mit Dateien mit Java

Ich möchte ein Verzeichnis mit Java erstellen und löschen, aber es funktioniert nicht.

File index = new File("/home/Work/Indexer1");
if (!index.exists()) {
    index.mkdir();
} else {
    index.delete();
    if (!index.exists()) {
        index.mkdir();
    }
}

Java kann keine Ordner mit darin enthaltenen Daten löschen. Sie müssen alle Dateien löschen, bevor Sie den Ordner löschen.

Verwenden Sie etwas wie:

String[]entries = index.list();
for(String s: entries){
    File currentFile = new File(index.getPath(),s);
    currentFile.delete();
}

Dann sollten Sie in der Lage sein, den Ordner mit index.delete() Untested zu löschen !

Nur ein Einzeiler.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

Dokumentation hier

Dies funktioniert, und obwohl es ineffizient erscheint, den Verzeichnistest zu überspringen, ist dies nicht der Fall: Der Test findet sofort in statt listFiles().

void deleteDir(File file) {
    File[] contents = file.listFiles();
    if (contents != null) {
        for (File f : contents) {
            deleteDir(f);
        }
    }
    file.delete();
}

Aktualisieren Sie, um folgende symbolische Links zu vermeiden:

void deleteDir(File file) {
    File[] contents = file.listFiles();
    if (contents != null) {
        for (File f : contents) {
            if (! Files.isSymbolicLink(f.toPath())) {
                deleteDir(f);
            }
        }
    }
    file.delete();
}

Ich bevorzuge diese Lösung auf Java 8:

  Files.walk(pathToBeDeleted)
    .sorted(Comparator.reverseOrder())
    .map(Path::toFile)
    .forEach(File::delete);

Von dieser Site: http://www.baeldung.com/java-delete-directory

In JDK 7 können Sie einen Dateibaum verwenden Files.walkFileTree()und Files.deleteIfExists()löschen. (Beispiel: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )

In JDK 6 besteht eine Möglichkeit darin, FileUtils.deleteQuietly aus Apache Commons zu verwenden, um eine Datei, ein Verzeichnis oder ein Verzeichnis mit Dateien und Unterverzeichnissen zu entfernen.

Mit Apache Commons-IO folgt es einem Einzeiler:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

Dies ist (etwas) performanter als FileUtils.deleteDirectory.

Wie bereits erwähnt, kann Java keinen Ordner löschen, der Dateien enthält. Löschen Sie daher zuerst die Dateien und dann den Ordner.

Hier ist ein einfaches Beispiel dafür:

import org.apache.commons.io.FileUtils;



// First, remove files from into the folder 
FileUtils.cleanDirectory(folder/path);

// Then, remove the folder
FileUtils.deleteDirectory(folder/path);

Oder:

FileUtils.forceDelete(new File(destination));

Meine rekursive Basisversion, die mit älteren Versionen von JDK arbeitet:

public static void deleteFile(File element) {
    if (element.isDirectory()) {
        for (File sub : element.listFiles()) {
            deleteFile(sub);
        }
    }
    element.delete();
}

Dies ist die beste Lösung für Java 7+:

public static void deleteDirectory(String directoryFilePath) throws IOException
{
    Path directory = Paths.get(directoryFilePath);

    if (Files.exists(directory))
    {
        Files.walkFileTree(directory, new SimpleFileVisitor<Path>()
        {
            @Override
            public FileVisitResult visitFile(Path path, BasicFileAttributes basicFileAttributes) throws IOException
            {
                Files.delete(path);
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path directory, IOException ioException) throws IOException
            {
                Files.delete(directory);
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

Guave 21+ zur Rettung. Nur verwenden, wenn keine Symlinks auf das zu löschende Verzeichnis verweisen.

com.google.common.io.MoreFiles.deleteRecursively(
      file.toPath(),
      RecursiveDeleteOption.ALLOW_INSECURE
) ;

(Diese Frage ist von Google gut indiziert, sodass andere Benutzer von Guava diese Antwort möglicherweise gerne finden, auch wenn sie mit anderen Antworten an anderer Stelle überflüssig ist.)

Diese Lösung gefällt mir am besten. Es wird keine Bibliothek von Drittanbietern verwendet, sondern NIO2 von Java 7.

/**
 * Deletes Folder with all of its content
 *
 * @param folder path to folder which should be deleted
 */
public static void deleteFolderAndItsContent(final Path folder) throws IOException {
    Files.walkFileTree(folder, 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 {
            if (exc != null) {
                throw exc;
            }
            Files.delete(dir);
            return FileVisitResult.CONTINUE;
        }
    });
}

Eine weitere Möglichkeit besteht darin, die org.springframework.util.FileSystemUtilsrelevante Methode von Spring zu verwenden, mit der der gesamte Inhalt des Verzeichnisses rekursiv gelöscht wird.

File directoryToDelete = new File(<your_directory_path_to_delete>);
FileSystemUtils.deleteRecursively(directoryToDelete);

Das wird den Job machen!

In diesem

index.delete();

            if (!index.exists())
               {
                   index.mkdir();
               }

Du rufst an

 if (!index.exists())
                   {
                       index.mkdir();
                   }

nach dem

index.delete();

Dies bedeutet, dass Sie die Datei nach dem Löschen von File.delete () erneut erstellen und einen booleschen Wert zurückgeben. Wenn Sie dies überprüfen möchten, tun System.out.println(index.delete());Sie dies, wenn Sie erhaltentrue Dies bedeutet, dass die Datei gelöscht wird

File index = new File("/home/Work/Indexer1");
    if (!index.exists())
       {
             index.mkdir();
       }
    else{
            System.out.println(index.delete());//If you get true then file is deleted




            if (!index.exists())
               {
                   index.mkdir();// here you are creating again after deleting the file
               }




        }

Aus den unten angegebenen Kommentaren geht hervor , dass die aktualisierte Antwort so lautet

File f=new File("full_path");//full path like c:/home/ri
    if(f.exists())
    {
        f.delete();
    }
    else
    {
        try {
            //f.createNewFile();//this will create a file
            f.mkdir();//this create a folder
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

Wenn Sie Unterordner haben, werden Sie Probleme mit den Cemron-Antworten finden. Sie sollten also eine Methode erstellen, die folgendermaßen funktioniert:

private void deleteTempFile(File tempFile) {
        try
        {
            if(tempFile.isDirectory()){
               File[] entries = tempFile.listFiles();
               for(File currentFile: entries){
                   deleteTempFile(currentFile);
               }
               tempFile.delete();
            }else{
               tempFile.delete();
            }
        getLogger().info("DELETED Temporal File: " + tempFile.getPath());
        }
        catch(Throwable t)
        {
            getLogger().error("Could not DELETE file: " + tempFile.getPath(), t);
        }
    }

Sie können FileUtils.deleteDirectory verwenden . JAVA kann die nicht leeren Foldres nicht mit File.delete () löschen .

directry kann nicht einfach löschen, wenn die Dateien vorhanden sind. Daher müssen Sie möglicherweise zuerst die Dateien im Verzeichnis und dann im Verzeichnis löschen

public class DeleteFileFolder {

public DeleteFileFolder(String path) {

    File file = new File(path);
    if(file.exists())
    {
        do{
            delete(file);
        }while(file.exists());
    }else
    {
        System.out.println("File or Folder not found : "+path);
    }

}
private void delete(File file)
{
    if(file.isDirectory())
    {
        String fileList[] = file.list();
        if(fileList.length == 0)
        {
            System.out.println("Deleting Directory : "+file.getPath());
            file.delete();
        }else
        {
            int size = fileList.length;
            for(int i = 0 ; i < size ; i++)
            {
                String fileName = fileList[i];
                System.out.println("File path : "+file.getPath()+" and name :"+fileName);
                String fullPath = file.getPath()+"/"+fileName;
                File fileOrFolder = new File(fullPath);
                System.out.println("Full Path :"+fileOrFolder.getPath());
                delete(fileOrFolder);
            }
        }
    }else
    {
        System.out.println("Deleting file : "+file.getPath());
        file.delete();
    }
}

Sie können rekursiv aufrufen, wenn Unterverzeichnisse vorhanden sind

import java.io.File;

class DeleteDir {
public static void main(String args[]) {
deleteDirectory(new File(args[0]));
}

static public boolean deleteDirectory(File path) {
if( path.exists() ) {
  File[] files = path.listFiles();
  for(int i=0; i<files.length; i++) {
     if(files[i].isDirectory()) {
       deleteDirectory(files[i]);
     }
     else {
       files[i].delete();
     }
  }
}
return( path.delete() );
}
}

wir können die spring-coreAbhängigkeit nutzen;

boolean result = FileSystemUtils.deleteRecursively(file);

Die meisten Antworten (auch neuere), die auf JDK-Klassen verweisen, basieren auf, File.delete()aber dies ist eine fehlerhafte API, da der Vorgang möglicherweise unbemerkt fehlschlägt.
In der java.io.File.delete()Methodendokumentation heißt es:

Beachten Sie, dass die java.nio.file.FilesKlasse die deleteMethode definiert, die ausgelöst werden soll, IOExceptionwenn eine Datei nicht gelöscht werden kann. Dies ist nützlich für die Fehlerberichterstattung und um zu diagnostizieren, warum eine Datei nicht gelöscht werden kann.

Als Ersatz sollten Sie bevorzugen, Files.delete(Path p) dass eine IOExceptionmit einer Fehlermeldung ausgelöst wird.

Der eigentliche Code könnte wie folgt geschrieben werden:

Path index = Paths.get("/home/Work/Indexer1");

if (!Files.exists(index)) {
    index = Files.createDirectories(index);
} else {

    Files.walk(index)
         .sorted(Comparator.reverseOrder())  // as the file tree is traversed depth-first and that deleted dirs have to be empty  
         .forEach(t -> {
             try {
                 Files.delete(t);
             } catch (IOException e) {
                 // LOG the exception and potentially stop the processing

             }
         });
    if (!Files.exists(index)) {
        index = Files.createDirectories(index);
    }
}

Sie können wie folgt versuchen

  File dir = new File("path");
   if (dir.isDirectory())
   {
         dir.delete();
   }

Wenn sich in Ihrem Ordner Unterordner befinden, müssen Sie diese möglicherweise rekursiv löschen.

private void deleteFileOrFolder(File file){
    try {
        for (File f : file.listFiles()) {
            f.delete();
            deleteFileOrFolder(f);
        }
    } catch (Exception e) {
        e.printStackTrace(System.err);
    }
}

        import org.apache.commons.io.FileUtils;

        List<String> directory =  new ArrayList(); 
        directory.add("test-output"); 
        directory.add("Reports/executions"); 
        directory.add("Reports/index.html"); 
        directory.add("Reports/report.properties"); 
        for(int count = 0 ; count < directory.size() ; count ++)
        {
        String destination = directory.get(count);
        deleteDirectory(destination);
        }





      public void deleteDirectory(String path) {

        File file  = new File(path);
        if(file.isDirectory()){
             System.out.println("Deleting Directory :" + path);
            try {
                FileUtils.deleteDirectory(new File(path)); //deletes the whole folder
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        else {
        System.out.println("Deleting File :" + path);
            //it is a simple file. Proceed for deletion
            file.delete();
        }

    }

Klappt wunderbar . Für Ordner und Dateien. Salam :)

Entfernen Sie es vom anderen Teil

File index = new File("/home/Work/Indexer1");
if (!index.exists())
{
     index.mkdir();
     System.out.println("Dir Not present. Creating new one!");
}
index.delete();
System.out.println("File deleted successfully");

Einige dieser Antworten scheinen unnötig lang zu sein:

if (directory.exists()) {
    for (File file : directory.listFiles()) {
        file.delete();
    }
    directory.delete();
}

Funktioniert auch für Unterverzeichnisse.

Sie können diese Funktion verwenden

public void delete()    
{   
    File f = new File("E://implementation1/");
    File[] files = f.listFiles();
    for (File file : files) {
        file.delete();
    }
}