Tüm dizinleri tekrar tekrar Java ile silmenin bir yolu var mı?

Normal durumda boş bir dizini silmek mümkündür. Bununla birlikte, tüm dizinleri içeriklerle silmek söz konusu olduğunda, artık o kadar basit değil.

Java'da içerik barındıran tüm dizinleri nasıl silebilirsiniz?

Apache'nin müştereklerini kontrol etmelisiniz . İstediğinizi yapacak bir FileUtils sınıfına sahiptir.

FileUtils.deleteDirectory(new File("directory"));

Java 7 ile bunu güvenilir symlink algılamasıyla yapabiliriz. (Apache'nin müşterilerinin şu anda oluşturulmuş Windows bağlantılarını işlemediği için güvenilir symlink algılamasına sahip olduğunu düşünmüyorum mklink.)

Tarih uğruna, sembolik bağlantıları takip eden Java öncesi 7 cevabı .

void delete(File f) throws IOException {
  if (f.isDirectory()) {
    for (File c : f.listFiles())
      delete(c);
  }
  if (!f.delete())
    throw new FileNotFoundException("Failed to delete file: " + f);
}

Java 7 ve sonraki sürümlerinde Filessınıfı kullanabilirsiniz . Kod çok basit:

Path directory = Paths.get("/tmp");
Files.walkFileTree(directory, 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 {
       Files.delete(dir);
       return FileVisitResult.CONTINUE;
   }
});

Başlangıç ​​dizini de dahil olmak üzere tüm dosyaları ve dizinleri yinelemeli olarak silmek için tek astarlı bir çözüm (Java8) :

Files.walk(Paths.get("c:/dir_to_delete/"))
                .map(Path::toFile)
                .sorted((o1, o2) -> -o1.compareTo(o2))
                .forEach(File::delete);

Ters sipariş için bir karşılaştırıcı kullanıyoruz, aksi takdirde File :: delete muhtemelen boş olmayan dizini silemez. Bu nedenle, dizinleri saklamak ve yalnızca dosyaları silmek istiyorsanız, karşılaştırıcıyı sıralanmış () olarak kaldırın veya sıralamayı tamamen kaldırın ve dosya filtresi ekleyin:

Files.walk(Paths.get("c:/dir_to_delete/"))
                .filter(Files::isRegularFile)
                .map(Path::toFile)
                .forEach(File::delete);

Java 7, symlink işleme özelliğine sahip yürüyüş dizinleri için destek ekledi:

import java.nio.file.*;

public static void removeRecursive(Path path) throws IOException
{
    Files.walkFileTree(path, new SimpleFileVisitor<Path>()
    {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
                throws IOException
        {
            Files.delete(file);
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException
        {
            // try to delete the file anyway, even if its attributes
            // could not be read, since delete-only access is
            // theoretically possible
            Files.delete(file);
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException
        {
            if (exc == null)
            {
                Files.delete(dir);
                return FileVisitResult.CONTINUE;
            }
            else
            {
                // directory iteration failed; propagate exception
                throw exc;
            }
        }
    });
}

Bu platforma özgü yöntemlerden (bu test edilmemiş kodda) bir yedek olarak kullanın :

public static void removeDirectory(Path directory) throws IOException
{
    // does nothing if non-existent
    if (Files.exists(directory))
    {
        try
        {
            // prefer OS-dependent directory removal tool
            if (SystemUtils.IS_OS_WINDOWS)
                Processes.execute("%ComSpec%", "/C", "RD /S /Q \"" + directory + '"');
            else if (SystemUtils.IS_OS_UNIX)
                Processes.execute("/bin/rm", "-rf", directory.toString());
        }
        catch (ProcessExecutionException | InterruptedException e)
        {
            // fallback to internal implementation on error
        }

        if (Files.exists(directory))
            removeRecursive(directory);
    }
}

(SystemUtils, Apache Commons Lang'dan alınmıştır . İşlemler özeldir, ancak davranışı açık olmalıdır.)

Çözümümün erickson'la hemen hemen aynı olduğunu gördüm, sadece statik bir yöntem olarak paketlendi. Bunu bir yere bırakın, (gördüğünüz gibi) oldukça basit bir şey için tüm Apache Commons'ı kurmaktan çok daha hafiftir.

public class FileUtils {
    /**
     * By default File#delete fails for non-empty directories, it works like "rm". 
     * We need something a little more brutual - this does the equivalent of "rm -r"
     * @param path Root File Path
     * @return true iff the file and all sub files/directories have been removed
     * @throws FileNotFoundException
     */
    public static boolean deleteRecursive(File path) throws FileNotFoundException{
        if (!path.exists()) throw new FileNotFoundException(path.getAbsolutePath());
        boolean ret = true;
        if (path.isDirectory()){
            for (File f : path.listFiles()){
                ret = ret && deleteRecursive(f);
            }
        }
        return ret && path.delete();
    }
}

Yığınlı ve özyinelemeli yöntemler olmayan bir çözüm:

File dir = new File("/path/to/dir");
File[] currList;
Stack<File> stack = new Stack<File>();
stack.push(dir);
while (! stack.isEmpty()) {
    if (stack.lastElement().isDirectory()) {
        currList = stack.lastElement().listFiles();
        if (currList.length > 0) {
            for (File curr: currList) {
                stack.push(curr);
            }
        } else {
            stack.pop().delete();
        }
    } else {
        stack.pop().delete();
    }
}

Eğer bahar varsa, kullanabilirsiniz FileSystemUtils.deleteRecursively :

import org.springframework.util.FileSystemUtils;

boolean success = FileSystemUtils.deleteRecursively(new File("directory"));

Guava , Guava 9'aFiles.deleteRecursively(File) kadar destek vermişti .

Gönderen Guava 10 :

Kullanımdan kaldırıldı. Bu yöntem zayıf sembolik algılama ve yarış koşullarından muzdariptir. Bu işlevsellik uygun şekilde yalnızca rm -rfveya gibi bir işletim sistemi komutuna bombardıman yapılarak desteklenebilir del /s. Bu yöntemin Guava 11.0 sürümünde Guava'dan kaldırılması planlanmaktadır.

Bu nedenle, Guava 11'de böyle bir yöntem yoktur .

for(Path p : Files.walk(directoryToDelete).
        sorted((a, b) -> b.compareTo(a)). // reverse; files before dirs
        toArray(Path[]::new))
{
    Files.delete(p);
}

Veya aşağıdakileri işlemek istiyorsanız IOException:

Files.walk(directoryToDelete).
    sorted((a, b) -> b.compareTo(a)). // reverse; files before dirs
    forEach(p -> {
        try { Files.delete(p); }
        catch(IOException e) { /* ... */ }
      });

public void deleteRecursive(File path){
    File[] c = path.listFiles();
    System.out.println("Cleaning out folder:" + path.toString());
    for (File file : c){
        if (file.isDirectory()){
            System.out.println("Deleting file:" + file.toString());
            deleteRecursive(file);
            file.delete();
        } else {
            file.delete();
        }
    }
    path.delete();
}

static public void deleteDirectory(File path) 
{
    if (path == null)
        return;
    if (path.exists())
    {
        for(File f : path.listFiles())
        {
            if(f.isDirectory()) 
            {
                deleteDirectory(f);
                f.delete();
            }
            else
            {
                f.delete();
            }
        }
        path.delete();
    }
}

Symlinks ve yukarıdaki kodla başarısız olmanın iki yolu ... ve çözümü bilmiyorum.

Yol # 1

Bir test oluşturmak için bunu çalıştırın:

echo test > testfile
mkdir dirtodelete
ln -s badlink dirtodelete/badlinktodelete

Test dosyanızı ve test dizininizi burada görebilirsiniz:

$ ls testfile dirtodelete
testfile

dirtodelete:
linktodelete

Sonra commons-io deleteDirectory () komutunu çalıştırın. Dosyanın bulunmadığını söyleyerek çöküyor. Diğer örneklerin burada ne yaptığından emin değilim. Linux rm komutu basitçe bağlantıyı siler ve dizindeki rm -r de olur.

Exception in thread "main" java.io.FileNotFoundException: File does not exist: /tmp/dirtodelete/linktodelete

Yol # 2

Bir test oluşturmak için bunu çalıştırın:

mkdir testdir
echo test > testdir/testfile
mkdir dirtodelete
ln -s ../testdir dirtodelete/dirlinktodelete

Test dosyanızı ve test dizininizi burada görebilirsiniz:

$ ls dirtodelete testdir
dirtodelete:
dirlinktodelete

testdir:
testfile

Ardından, commons-io deleteDirectory () öğenizi veya kişilerin yayınladığı örnek kodu çalıştırın. Yalnızca dizini değil, silinmekte olan dizinin dışındaki sınama dosyanızı da siler. (Dizini dolaylı olarak dereferences ve içeriği siler). rm -r yalnızca bağlantıyı siler. Bunun gibi bir şey kullanmanız gerekir, referansı silinmiş dosyaları silin: "find -L dirtodelete -type f -exec rm {} \;".

$ ls dirtodelete testdir
ls: cannot access dirtodelete: No such file or directory
testdir:

Kullanabilirsin:

org.apache.commons.io.FileUtils.deleteQuietly(destFile);

Asla istisna atmayan bir dosyayı siler. Dosya bir dizinse, dizini ve tüm alt dizinleri silin. File.delete () ve bu yöntem arasındaki fark şunlardır: Silinecek bir dizinin boş olması gerekmez. Bir dosya veya dizin silinemediğinde istisna yapılmaz.

Bir yöntemden atılan bir özel durumun her zaman bu yöntemin ne yapmaya çalıştığını (ve başarısız olduğunu) tanımlaması gerektiği yaklaşımıyla tutarlı bir şekilde istisnayı işleyen en uygun çözüm:

private void deleteRecursive(File f) throws Exception {
    try {
        if (f.isDirectory()) {
            for (File c : f.listFiles()) {
                deleteRecursive(c);
            }
        }
        if (!f.delete()) {
            throw new Exception("Delete command returned false for file: " + f);
        }
    } 
    catch (Exception e) {
        throw new Exception("Failed to delete the folder: " + f, e);
    }
}

Eski projelerde, yerel Java kodu oluşturmam gerekiyor. Bu kodu Paulitex koduna benzer şekilde oluşturuyorum. Şuna bakın:

public class FileHelper {

   public static boolean delete(File fileOrFolder) {
      boolean result = true;
      if(fileOrFolder.isDirectory()) {
         for (File file : fileOrFolder.listFiles()) {
            result = result && delete(file);
         }
      }
      result = result && fileOrFolder.delete();
      return result;
   } 
}

Ve birim testi:

public class FileHelperTest {

    @Before
    public void setup() throws IOException {
       new File("FOLDER_TO_DELETE/SUBFOLDER").mkdirs();
       new File("FOLDER_TO_DELETE/SUBFOLDER_TWO").mkdirs();
       new File("FOLDER_TO_DELETE/SUBFOLDER_TWO/TEST_FILE.txt").createNewFile();
    }

    @Test
    public void deleteFolderWithFiles() {
       File folderToDelete = new File("FOLDER_TO_DELETE");
       Assert.assertTrue(FileHelper.delete(folderToDelete));
       Assert.assertFalse(new File("FOLDER_TO_DELETE").exists());
    }

}

Aşağıdaki kod, belirli bir klasördeki tüm içeriği tekrar tekrar siler.

boolean deleteDirectory(File directoryToBeDeleted) {
    File[] allContents = directoryToBeDeleted.listFiles();
    if (allContents != null) {
        for (File file : allContents) {
            deleteDirectory(file);
        }
    }
    return directoryToBeDeleted.delete();
}

İşte bir komut satırı argümanını kabul eden çıplak kemikler ana yöntemi, kendi hata kontrolünüzü eklemeniz veya uygun gördüğünüz şekilde kalıplamanız gerekebilir.

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;

public class DeleteFiles {

/**
 * @param intitial arguments take in a source to read from and a 
 * destination to read to
 */
    public static void main(String[] args)
                     throws FileNotFoundException,IOException {
        File src = new File(args[0]);
        if (!src.exists() ) {
            System.out.println("FAILURE!");
        }else{
            // Gathers files in directory
            File[] a = src.listFiles();
            for (int i = 0; i < a.length; i++) {
                //Sends files to recursive deletion method
                fileDelete(a[i]);
            }
            // Deletes original source folder
            src.delete();
            System.out.println("Success!");
        }
    }

    /**
     * @param srcFile Source file to examine
     * @throws FileNotFoundException if File not found
     * @throws IOException if File not found
     */
    private static void fileDelete(File srcFile)
                     throws FileNotFoundException, IOException {
        // Checks if file is a directory
        if (srcFile.isDirectory()) {
            //Gathers files in directory
            File[] b = srcFile.listFiles();
            for (int i = 0; i < b.length; i++) {
                //Recursively deletes all files and sub-directories
                fileDelete(b[i]);
            }
            // Deletes original sub-directory file
            srcFile.delete();
        } else {
            srcFile.delete();
        }
    }
}

Umarım bu yardımcı olur!

Belki de bu sorunun çözümü erickson'un cevabındaki kodu kullanarak File sınıfının delete yöntemini yeniden uygulamak olabilir:

public class MyFile extends File {

  ... <- copy constructor

  public boolean delete() {
    if (f.isDirectory()) {
      for (File c : f.listFiles()) {
        return new MyFile(c).delete();
      }
    } else {
        return f.delete();
    }
  }
}

Commons IO ve <Java SE 7 olmadan

public static void deleteRecursive(File path){
            path.listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    if (pathname.isDirectory()) {
                        pathname.listFiles(this);
                        pathname.delete();
                    } else {
                        pathname.delete();
                    }
                    return false;
                }
            });
            path.delete();
        }

Dosyalar file.delete () kullanılarak kolayca silinebilse de, dizinlerin silinmesi için boş olması gerekir. Bunu kolayca yapmak için özyineleme kullanın. Örneğin:

public static void clearFolders(String[] args) {
        for(String st : args){
            File folder = new File(st);
            if (folder.isDirectory()) {
                File[] files = folder.listFiles();
                if(files!=null) { 
                    for(File f: files) {
                        if (f.isDirectory()){
                            clearFolders(new String[]{f.getAbsolutePath()});
                            f.delete();
                        } else {
                            f.delete();
                        }
                    }
                }
            }
        }
    }

daha güvenli kullanım için 3 güvenlik kriteri olan bu rutini kodladım.

package ch.ethz.idsc.queuey.util;

import java.io.File;
import java.io.IOException;

/** recursive file/directory deletion
 * 
 * safety from erroneous use is enhanced by three criteria
 * 1) checking the depth of the directory tree T to be deleted
 * against a permitted upper bound "max_depth"
 * 2) checking the number of files to be deleted #F
 * against a permitted upper bound "max_count"
 * 3) if deletion of a file or directory fails, the process aborts */
public final class FileDelete {
    /** Example: The command
     * FileDelete.of(new File("/user/name/myapp/recordings/log20171024"), 2, 1000);
     * deletes given directory with sub directories of depth of at most 2,
     * and max number of total files less than 1000. No files are deleted
     * if directory tree exceeds 2, or total of files exceed 1000.
     * 
     * abort criteria are described at top of class
     * 
     * @param file
     * @param max_depth
     * @param max_count
     * @return
     * @throws Exception if criteria are not met */
    public static FileDelete of(File file, int max_depth, int max_count) throws IOException {
        return new FileDelete(file, max_depth, max_count);
    }

    // ---
    private final File root;
    private final int max_depth;
    private int removed = 0;

    /** @param root file or a directory. If root is a file, the file will be deleted.
     *            If root is a directory, the directory tree will be deleted.
     * @param max_depth of directory visitor
     * @param max_count of files to delete
     * @throws IOException */
    private FileDelete(final File root, final int max_depth, final int max_count) throws IOException {
        this.root = root;
        this.max_depth = max_depth;
        // ---
        final int count = visitRecursively(root, 0, false);
        if (count <= max_count) // abort criteria 2)
            visitRecursively(root, 0, true);
        else
            throw new IOException("more files to be deleted than allowed (" + max_count + "<=" + count + ") in " + root);
    }

    private int visitRecursively(final File file, final int depth, final boolean delete) throws IOException {
        if (max_depth < depth) // enforce depth limit, abort criteria 1)
            throw new IOException("directory tree exceeds permitted depth");
        // ---
        int count = 0;
        if (file.isDirectory()) // if file is a directory, recur
            for (File entry : file.listFiles())
                count += visitRecursively(entry, depth + 1, delete);
        ++count; // count file as visited
        if (delete) {
            final boolean deleted = file.delete();
            if (!deleted) // abort criteria 3)
                throw new IOException("cannot delete " + file.getAbsolutePath());
            ++removed;
        }
        return count;
    }

    public int deletedCount() {
        return removed;
    }

    public void printNotification() {
        int count = deletedCount();
        if (0 < count)
            System.out.println("deleted " + count + " file(s) in " + root);
    }
}

Bir örnek alalım,

import java.io.File;
import java.io.IOException;

public class DeleteDirectory
{
   private static final String folder = "D:/project/java";

   public static void main(String[] args) throws IOException
   {
      File fl = new File(folder);
      if(!fl.exists()) // checking if directory exists
      {
         System.out.println("Sorry!! directory doesn't exist.");
      }
      else
      {
         DeleteDirectory dd = new DeleteDirectory();
         dd.deleteDirectory(fl);
      }
   }

   public void deleteDirectory(File file) throws IOException
   {
      if(file.isDirectory())
      {
         if(file.list().length == 0)
         { 
            deleteEmptyDirectory(file); // here if directory is empty delete we are deleting
         }
         else
         {
            File fe[] = file.listFiles();
            for(File deleteFile : fe)
            {
               deleteDirectory(deleteFile); // recursive call
            }
            if(file.list().length == 0)
            {
               deleteEmptyDirectory(file);
            }
         }
      }
      else
      {
         file.delete();
         System.out.println("File deleted : " + file.getAbsolutePath());
      }
   }

   private void deleteEmptyDirectory(File fi)
   {
      fi.delete();
      System.out.println("Directory deleted : " + fi.getAbsolutePath());
   }
}

Daha fazla bilgi için aşağıdaki kaynaklara bakın

Dizini sil

rm -rfoldu çok daha daha fazla ölçülebilir FileUtils.deleteDirectory.

Kapsamlı kıyaslamadan sonra, kullanımın kullanmaktan rm -rfçok daha hızlı olduğunu gördükFileUtils.deleteDirectory .

Tabii ki, küçük veya basit bir dizininiz varsa, önemli değil, ancak bizim durumumuzda birden fazla gigabayt ve 10 dakikadan fazla sürecek derin iç içe alt dizinlerimiz vardı. FileUtils.deleteDirectory ve sadece 1 dakika 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 deleteDirectory( 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();

        return true;
    }

    return false;

}

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

Guava tek kılıfı sağlamaktadır: MoreFiles.deleteRecursively().

Paylaşılan örneklerin çoğundan farklı olarak, sembolik bağlantıları açıklar ve sağlanan yolun dışındaki dosyaları (varsayılan olarak) silmez.