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

Je souhaite créer et supprimer un répertoire à l'aide de Java, mais cela ne fonctionne pas.

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

Java ne peut pas supprimer les dossiers contenant des données. Vous devez supprimer tous les fichiers avant de supprimer le dossier.

Utilisez quelque chose comme:

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

Ensuite, vous devriez pouvoir supprimer le dossier en utilisant index.delete() Non testé!

Juste une seule ligne.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

Documentation ici

Cela fonctionne, et même s'il semble inefficace de sauter le test de répertoire, ce n'est pas le cas: le test se déroule tout de suite dans listFiles().

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

Mettre à jour, pour éviter les liens symboliques suivants:

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

Je préfère cette solution sur java 8:

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

Depuis ce site: http://www.baeldung.com/java-delete-directory

Dans JDK 7, vous pouvez utiliser Files.walkFileTree()et Files.deleteIfExists()supprimer une arborescence de fichiers. (Exemple: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )

Dans JDK 6, une manière possible est d'utiliser FileUtils.deleteQuietly d'Apache Commons qui supprimera un fichier, un répertoire ou un répertoire avec des fichiers et des sous-répertoires.

En utilisant Apache Commons-IO, il suit une ligne:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

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

Comme mentionné, Java ne peut pas supprimer un dossier contenant des fichiers, supprimez donc d'abord les fichiers, puis le dossier.

Voici un exemple simple pour faire ceci:

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

Ma version récursive de base, fonctionnant avec les anciennes versions de JDK:

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

C'est la meilleure solution pour 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;
            }
        });
    }
}

Guava 21+ à la rescousse. À utiliser uniquement s'il n'y a aucun lien symbolique pointant vers le répertoire à supprimer.

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

(Cette question est bien indexée par Google, donc d'autres personnes utilisant Guava pourraient être heureuses de trouver cette réponse, même si elle est redondante avec d'autres réponses ailleurs.)

J'aime le plus cette solution. Il n'utilise pas de bibliothèque tierce, mais 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;
        }
    });
}

Un autre choix consiste à utiliser la org.springframework.util.FileSystemUtilsméthode pertinente de Spring qui supprimera récursivement tout le contenu du répertoire.

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

Cela fera l'affaire!

Dans ce

index.delete();

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

vous appelez

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

après

index.delete();

Cela signifie que vous créez à nouveau le fichier après la suppression de File.delete () renvoie une valeur booléenne.Donc si vous voulez vérifier, faites System.out.println(index.delete());si vous obtenez truecela 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
               }




        }

à partir des commentaires ci-dessous, la réponse mise à jour est comme ceci

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

Si vous avez des sous-dossiers, vous trouverez des problèmes avec les réponses Cemron. vous devez donc 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);
        }
    }

Vous pouvez utiliser FileUtils.deleteDirectory . JAVA ne peut pas supprimer les dossiers non vides avec File.delete () .

Directry ne peut pas simplement supprimer s'il contient les fichiers, vous devrez peut-être supprimer les fichiers à l'intérieur d'abord, puis le répertoire

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

Vous pouvez effectuer un appel récursif si des sous-répertoires existent

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

nous pouvons utiliser la spring-coredépendance;

boolean result = FileSystemUtils.deleteRecursively(file);

La plupart des réponses (même récentes) faisant référence aux classes JDK s'appuient sur, File.delete()mais il s'agit d'une API défectueuse car l'opération peut échouer silencieusement.
La java.io.File.delete()documentation de la méthode indique:

Notez que la java.nio.file.Filesclasse définit la deleteméthode à lancer IOExceptionlorsqu'un fichier ne peut pas être supprimé. Ceci est utile pour le rapport d'erreurs et pour diagnostiquer pourquoi un fichier ne peut pas être supprimé.

En remplacement, vous devriez privilégier Files.delete(Path p) qui jette un IOExceptionavec un message d'erreur.

Le code réel pourrait être écrit tel que:

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

vous pouvez essayer comme suit

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

S'il y a des sous-dossiers dans votre dossier, vous devrez peut-être les supprimer de manière récursive.

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

    }

Fonctionne comme un charme. Pour les dossiers et les fichiers. Salam :)

Retirez-le d'une autre partie

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

Certaines de ces réponses semblent inutilement longues:

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

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