Je veux supprimer tous les fichiers du répertoire ABC.

Lorsque j'ai essayé, FileUtils.deleteDirectory(new File("C:/test/ABC/"));il supprime également le dossier ABC.

Existe-t-il une solution à une ligne où je peux supprimer des fichiers dans le répertoire mais pas dans le répertoire?

import org.apache.commons.io.FileUtils;

FileUtils.cleanDirectory(directory); 

Cette méthode est disponible dans le même fichier. Cela supprimera également de manière récursive tous les sous-dossiers et fichiers qui s'y trouvent.

Documents: org.apache.commons.io.FileUtils.cleanDirectory

Voulez-vous dire comme?

for(File file: dir.listFiles()) 
    if (!file.isDirectory()) 
        file.delete();

Cela supprimera uniquement les fichiers, pas les répertoires.

La réponse de Peter Lawrey est excellente car elle est simple et ne dépend de rien de spécial, et c'est la façon dont vous devez le faire. Si vous avez besoin de quelque chose qui supprime également les sous-répertoires et leur contenu, utilisez la récursivité:

void purgeDirectory(File dir) {
    for (File file: dir.listFiles()) {
        if (file.isDirectory())
            purgeDirectory(file);
        file.delete();
    }
}

Pour épargner des sous-répertoires et leur contenu (partie de votre question), modifiez comme suit:

void purgeDirectoryButKeepSubDirectories(File dir) {
    for (File file: dir.listFiles()) {
        if (!file.isDirectory())
            file.delete();
    }
}

Ou, puisque vous vouliez une solution à une ligne:

for (File file: dir.listFiles())
    if (!file.isDirectory())
        file.delete();

L'utilisation d'une bibliothèque externe pour une tâche aussi banale n'est pas une bonne idée à moins que vous n'ayez besoin de cette bibliothèque pour autre chose de toute façon, auquel cas il est préférable d'utiliser du code existant. Vous semblez utiliser la bibliothèque Apache de toute façon, utilisez donc sa FileUtils.cleanDirectory()méthode.

Flux Java 8

Cela supprime uniquement les fichiers de ABC (les sous-répertoires ne sont pas modifiés):

Arrays.stream(new File("C:/test/ABC/").listFiles()).forEach(File::delete);

Cela supprime uniquement les fichiers de l' ABC (et des sous-répertoires):

Files.walk(Paths.get("C:/test/ABC/"))
                .filter(Files::isRegularFile)
                .map(Path::toFile)
                .forEach(File::delete);

^ Cette version nécessite de gérer l'IOException

Ou pour l'utiliser en Java 8:

try {
  Files.newDirectoryStream( directory ).forEach( file -> {
    try { Files.delete( file ); }
    catch ( IOException e ) { throw new UncheckedIOException(e); }
  } );
}
catch ( IOException e ) {
  e.printStackTrace();
}

Dommage que la gestion des exceptions soit si encombrante, sinon ce serait un monoplace ...

public class DeleteFile {
    public static void main(String[] args) {
        String path="D:\test"; 
        File file = new File(path);
        File[] files = file.listFiles(); 
        for (File f:files) 
        {if (f.isFile() && f.exists) 
            { f.delete();
system.out.println("successfully deleted");
            }else{
system.out.println("cant delete a file due to open or error");
} }  }}

Une autre solution Java 8 Stream pour supprimer tout le contenu d'un dossier, sous-répertoires inclus, mais pas le dossier lui-même.

Usage:

Path folder = Paths.get("/tmp/folder");
CleanFolder.clean(folder);

et le code:

public interface CleanFolder {
    static void clean(Path folder) throws IOException {

        Function<Path, Stream<Path>> walk = p -> {
            try { return Files.walk(p);
        } catch (IOException e) {
            return Stream.empty();
        }};

        Consumer<Path> delete = p -> {
            try {
                Files.delete(p);
            } catch (IOException e) {
            }
        };

        Files.list(folder)
            .flatMap(walk)
            .sorted(Comparator.reverseOrder())
            .forEach(delete);
    }
}

Le problème avec chaque solution de flux impliquant Files.walk ou Files.delete est que ces méthodes génèrent des IOException qui sont difficiles à gérer dans les flux.

J'ai essayé de créer une solution la plus concise possible.

Pour supprimer tous les fichiers du répertoire, dites "C: \ Exemple"

File file = new File("C:\\Example");      
String[] myFiles;    
if (file.isDirectory()) {
    myFiles = file.list();
    for (int i = 0; i < myFiles.length; i++) {
        File myFile = new File(file, myFiles[i]); 
        myFile.delete();
    }
}

rm -rfétait beaucoup plus performant que FileUtils.cleanDirectory.

Il ne s'agit pas d'une solution monoligne, mais après une analyse comparative approfondie, nous avons constaté que l'utilisation rm -rfétait plusieurs fois plus rapide que l'utilisation FileUtils.cleanDirectory.

Bien sûr, si vous avez un répertoire petit ou simple, cela n'aura pas d'importance, mais dans notre cas, nous avions plusieurs gigaoctets et des sous-répertoires profondément imbriqués où cela prendrait plus de 10 minutes avec FileUtils.cleanDirectoryet seulement 1 minute avec rm -rf.

Voici notre implémentation Java approximative pour ce faire:

// Delete directory given and all subdirectories and files (i.e. recursively).
//
static public boolean clearDirectory( File file ) throws IOException, InterruptedException {

    if ( file.exists() ) {

        String deleteCommand = "rm -rf " + file.getAbsolutePath();
        Runtime runtime = Runtime.getRuntime();

        Process process = runtime.exec( deleteCommand );
        process.waitFor();

        file.mkdirs(); // Since we only want to clear the directory and not delete it, we need to re-create the directory.

        return true;
    }

    return false;

}

Il vaut la peine d'essayer si vous avez affaire à des répertoires volumineux ou complexes.

package com;
import java.io.File;
public class Delete {
    public static void main(String[] args) {

        String files; 
        File file = new File("D:\\del\\yc\\gh");
        File[] listOfFiles = file.listFiles(); 
        for (int i = 0; i < listOfFiles.length; i++) 
        {
            if (listOfFiles[i].isFile()) 
            {
                files = listOfFiles[i].getName();
                System.out.println(files);
                if(!files.equalsIgnoreCase("Scan.pdf"))
                {
                    boolean issuccess=new File(listOfFiles[i].toString()).delete();
                    System.err.println("Deletion Success "+issuccess);
                }
            }
        }
    }
}

Si vous souhaitez supprimer tous les fichiers, supprimez

if(!files.equalsIgnoreCase("Scan.pdf"))

déclaration, cela fonctionnera.

Je pense que cela fonctionnera (basé sur la réponse précédente de NonlinearFruit):

Files.walk(Paths.get("C:/test/ABC/"))
                .sorted(Comparator.reverseOrder())
                .map(Path::toFile)
                .filter(item -> !item.getPath().equals("C:/test/ABC/"))
                .forEach(File::delete);

À votre santé!