Java kullanılarak dosya içeren bir klasör nasıl silinir

Java kullanarak bir dizin oluşturmak ve silmek istiyorum, ancak çalışmıyor.

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

Java, içinde veri bulunan klasörleri silemez. Klasörü silmeden önce tüm dosyaları silmelisiniz.

Şunun gibi bir şey kullanın:

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

Ardından, index.delete() Test Edilmemiş'i kullanarak klasörü silebilirsiniz !

Sadece tek satırlık.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

Belgeler burada

Bu işe yarıyor ve dizin testini atlamak verimsiz görünse de, öyle değil: test hemen gerçekleşir listFiles().

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

Sembolik bağların izlenmesini önlemek için güncelleyin:

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

Bu çözümü java 8'de tercih ediyorum:

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

Bu siteden: http://www.baeldung.com/java-delete-directory

JDK 7'de bir dosya ağacını silmek için Files.walkFileTree()ve tuşlarını kullanabilirsiniz Files.deleteIfExists(). (Örnek: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )

JDK 6'da olası bir yol, bir dosyayı, bir dizini veya dosyalar ve alt dizinleri olan bir dizini kaldıracak olan FileUtils.deleteQuietly'yi Apache Commons'tan kullanmaktır .

Apache Commons-IO'yu kullanarak, tek satırlık bir programı izler:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

Bu (biraz) daha performanslı FileUtils.deleteDirectory.

Belirtildiği gibi, Java, dosyaları içeren bir klasörü silemez, bu nedenle önce dosyaları, ardından klasörü silin.

İşte bunu yapmak için basit bir örnek:

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

Veya:

FileUtils.forceDelete(new File(destination));

JDK'nın eski sürümleriyle çalışan temel yinelemeli sürümüm:

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

Aşağıdakiler için en iyi çözüm budur 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+ kurtarmaya. Yalnızca silinecek dizinin dışına işaret eden sembolik bağlantı yoksa kullanın.

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

(Bu soru Google tarafından iyi dizine eklenmiştir, bu nedenle Guava'yı kullanan diğer kişiler, başka bir yerde diğer yanıtlarla gereksiz olsa bile bu yanıtı bulmaktan mutlu olabilir.)

Bu çözümü en çok seviyorum. Üçüncü taraf kitaplığı kullanmaz, bunun yerine Java 7'nin NIO2'sini kullanır .

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

Bir seçenek daha org.springframework.util.FileSystemUtils, dizinin tüm içeriğini yinelemeli olarak silecek Spring'in ilgili yöntemini kullanmaktır .

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

Bu işi yapacak!

Bunda

index.delete();

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

sen arıyorsun

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

sonra

index.delete();

Eğer sildikten sonra dosyayı yeniden yaratmakta olduğu bu araçlar File.delete () yapmanız daha sonra kontrol etmek istiyorsanız bir boolean value.So döndürür System.out.println(index.delete());sen alırsanız truedosya silinir o zaman bu araçları

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
               }




        }

dan yapılan yorumlar aşağıda verilmiştir, güncellenmiş cevabı böyledir

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

Alt klasörleriniz varsa, Cemron cevaplarında sorun bulacaksınız. bu nedenle şu şekilde çalışan bir yöntem oluşturmalısınız:

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

FileUtils.deleteDirectory'yi kullanabilirsiniz . JAVA, boş olmayan katları File.delete () ile silemez .

directry, dosyalara sahipse basitçe silemez, bu nedenle önce içindeki dosyaları sonra dizini silmeniz gerekebilir.

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

Alt dizinler varsa özyinelemeli arama yapabilirsiniz

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

spring-corebağımlılığı kullanabiliriz ;

boolean result = FileSystemUtils.deleteRecursively(file);

JDK sınıflarına atıfta bulunan yanıtların çoğu (hatta en son) güveniyor, File.delete()ancak işlem sessizce başarısız olabileceği için bu hatalı bir API'dir. Yöntem belgelerine durumları:
java.io.File.delete()

java.nio.file.FilesSınıfın, bir dosya silinemediğinde deletefırlatma yöntemini tanımladığını unutmayın IOException. Bu, hata bildirimi ve bir dosyanın neden silinemediğini teşhis etmek için kullanışlıdır.

Değiştirilmesi gibi, iyilik etmelidir Files.delete(Path p) dair bir atar IOExceptionbir hata mesajı ile.

Gerçek kod şu şekilde yazılabilir:

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

aşağıdaki gibi deneyebilirsiniz

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

Klasörünüzün içinde alt klasörler varsa, bunları tekrar tekrar silmeniz gerekebilir.

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

    }

Tıkır tıkır çalışıyor . Hem klasör hem de dosyalar için. Salam :)

Başka bölümden kaldır

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

Bu cevaplardan bazıları gereksiz yere uzun görünüyor:

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

Alt dizinler için de çalışır.

Bu işlevi kullanabilirsiniz

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