Comment supprimer un dossier avec des fichiers à l'aide de Java

Java n'est pas en mesure de supprimer des dossiers avec des données. Vous devez supprimer tous les fichiers avant de supprimer le dossier.

Utiliser quelque chose comme:

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

Alors vous devriez être en mesure de supprimer le dossier à l'aide de index.delete()
Non testé!

Cela fonctionne, et bien qu'il semble inefficace pour ignorer le répertoire de test, il n'est pas: le test se passe tout de suite dans listFiles().

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

Mise à jour, pour éviter de suivre les liens symboliques:

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

À l'aide d'Apache Commons-IO, c'est la suite de one-liner:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

C'est (légèrement) plus performants que FileUtils.deleteDirectory.

Ma base une version récursive, en travaillant avec les anciennes versions de JDK:

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

J'aime cette solution le plus. Il n'utilise pas de 3ème partie de la bibliothèque, au lieu de cela il utilise NIO2 de 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;
        }
    });
}

Dans ce

index.delete();

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

vous appelez

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

après

index.delete();

Cela signifie que vous sont en train de créer le fichier à nouveau, après la suppression de
Fichier.delete() renvoie une valeur booléenne.Donc, si vous souhaitez vérifier, puis faire System.out.println(index.delete()); si vous obtenez true, alors cela signifie que le fichier est supprimé

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
               }




        }

de la commentaires donné ci-dessous,la mise à jour de la réponse, c'est comme cela

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

Comme mentionné, Java n'est pas en mesure de supprimer un dossier qui contient des fichiers, donc d'abord supprimer les fichiers et les dossiers.

Voici un exemple simple pour ce faire:

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

Ou:

FileUtils.forceDelete(new File(destination))

Si vous avez des sous-dossiers, vous trouverez des ennuis avec la Cemron réponses. donc, vous devez créer une méthode qui fonctionne comme ceci:

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

nous pouvons utiliser la spring-core de la dépendance;

boolean result = FileSystemUtils.deleteRecursively(file);

vous pouvez essayer comme suit

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

Si il y a des sous-dossiers à l'intérieur de votre dossier vous devrez peut-être supprimer de manière récursive eux.

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

    }

Fonctionne comme un Charme . Pour les dossier et les fichiers . Salam 🙂

Certaines de ces réponses semblent inutilement long:

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

Fonctionne également pour les sous répertoires.

Vous pouvez utiliser cette fonction

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