ABC dizini içindeki tüm dosyaları silmek istiyorum.

Onunla denediğimde FileUtils.deleteDirectory(new File("C:/test/ABC/"));ABC klasörünü de siler.

Dizin içindeki dosyaları silebilir, ancak dizin içindeki dosyaları silebileceğim tek bir çözüm var mı?

import org.apache.commons.io.FileUtils;

FileUtils.cleanDirectory(directory); 

Aynı dosyada bu yöntem vardır. Bu işlem aynı zamanda tüm alt klasörleri ve bunların altındaki dosyaları tekrar tekrar siler.

Dokümanlar: org.apache.commons.io.FileUtils.cleanDirectory

Şunu mu demek istediniz?

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

Bu sadece dosyaları siler, dizinleri silmez.

Peter Lawrey'in cevabı harika çünkü basit ve özel bir şeye bağlı değil ve bunu yapmanın yolu. Alt dizinleri ve içeriklerini de kaldıran bir şeye ihtiyacınız varsa özyineleme kullanın:

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

Alt dizinleri ve içeriklerini (sorunuzun bir parçası) yedeklemek için aşağıdaki gibi değiştirin:

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

Veya tek satırlık bir çözüm istediğiniz için:

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

Bu tür önemsiz bir görev için harici bir kütüphane kullanmak, başka bir şey için bu kütüphaneye ihtiyaç duymadıkça iyi bir fikir değildir, bu durumda mevcut kodun kullanılması tercih edilir. Yine de Apache kütüphanesini kullandığınız anlaşılıyor, bu yüzden onun FileUtils.cleanDirectory()yöntemini kullanın .

Java 8 Akışı

Bu yalnızca ABC'deki dosyaları siler (alt dizinlere dokunulmaz):

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

Bu yalnızca ABC'deki dosyaları (ve alt dizinleri) siler :

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

^ Bu sürüm IOException'ın kullanılmasını gerektirir

Veya bunu Java 8'de kullanmak için:

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

İstisna işlemenin bu kadar hantal olması üzücü, aksi takdirde bir astar olurdu ...

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

Bir klasörün tüm içeriğini silmek için başka bir Java 8 Stream çözümü, alt dizinler dahil, ancak klasörün kendisini değil.

Kullanımı:

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

ve kod:

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

Files.walk veya Files.delete içeren her akış çözümüyle ilgili sorun, bu yöntemlerin akışlarda işlemek için bir acı olan IOException oluşturmasıdır.

Mümkün olduğunca özlü bir çözüm yaratmaya çalıştım.

Dizindeki tüm dosyaları silmek için "C: \ Örnek" deyin

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 -rfoldu çok daha daha fazla ölçülebilir FileUtils.cleanDirectory.

Tek rm -rfkatmanlı bir çözüm değil, kapsamlı bir kıyaslamadan sonra, kullanımın kullanmaktan çok daha hızlı olduğunu gördük FileUtils.cleanDirectory.

Tabii ki, küçük veya basit bir dizininiz varsa, önemli değil, ancak bizim durumumuzda, birden fazla gigabayt ve 10 dakikadan fazla FileUtils.cleanDirectoryve sadece 1 dakika sürecek derin iç içe geçmiş alt dizinlerimiz vardı rm -rf.

İşte bunu yapmak için kaba Java uygulaması:

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

}

Büyük veya karmaşık dizinlerle uğraşıyorsanız denemeye değer.

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

Tüm dosyaları silmek istiyorsanız kaldırın

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

ifadesi işe yarayacaktır.

Bence bu işe yarayacaktır (NonlinearFruit önceki cevaba dayanarak):

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

Şerefe!