Comment supprimer un dossier avec des fichiers en utilisant Java

juste une doublure.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

Documentation ici

cela fonctionne, et bien qu'il semble inefficace de sauter le test de répertoire, ce n'est pas le cas: le test se produit 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 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();
}

dans JDK 7, vous pouvez utiliser Files.walkFileTree() et Files.deleteIfExists() pour supprimer un arbre de fichiers.

en JDK 6 une façon 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.

utilisant Apache Commons-IO, il est suivi d'un-liner:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

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

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

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

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

ma version de base récursive, travaillant avec des versions plus anciennes 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;
            }
        });
    }
}

cette solution me plaît le plus. Il n'utilise pas la bibliothèque de tiers, mais plutôt 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 créez à nouveau le fichier après la suppression fichier.delete () renvoie une valeur booléenne.Donc si vous voulez 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 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();
        }
    }

Goyave 21+ à la rescousse. Utilisez seulement s'il n'y a pas de liens symboliques pointant du répertoire à supprimer.

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

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

directry ne peut pas simplement supprimer si elle a les fichiers si vous pouvez avoir besoin de supprimer les fichiers à l'intérieur d'abord et ensuite 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();
    }
}

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

vous pouvez faire des appels récursifs 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() );
}
}

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.

Supprimer d'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");

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 pouvez avoir besoin de les supprimer de façon 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 dossier et les fichiers . Salam:)

nous pouvons utiliser la dépendance spring-core ;

boolean result = FileSystemUtils.deleteRecursively(file);

la plupart des réponses (même récentes) faisant référence aux classes JDK reposent sur File.delete() mais c'est une API défectueuse car l'opération peut échouer silencieusement.

La documentation de la méthode java.io.File.delete() indique:

noter que la classe java.nio.file.Files définit la méthode delete comme suit: jetez un IOException lorsqu'un fichier ne peut pas être supprimé. Ceci est utile pour rapport d'erreur et de diagnostiquer pourquoi un fichier ne peut pas être supprimer.

comme remplacement, vous devez favoriser Files.delete(Path p) qui lance un IOException avec un message d'erreur.

le code réel pourrait être écrit comme:

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

créer un répertoire -

File directory = new File("D:/Java/Example");
boolean isCreated = directory.mkdir();

Supprimer répertoire -

Consulter cette ressource pour des explications détaillées - supprimer le répertoire .

vous pouvez utiliser cette fonction

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