Cách xóa thư mục chứa tệp bằng Java

Tôi muốn tạo và xóa một thư mục bằng Java, nhưng nó không hoạt động.

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

Java không thể xóa các thư mục có dữ liệu trong đó. Bạn phải xóa tất cả các tệp trước khi xóa thư mục.

Sử dụng một cái gì đó như:

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

Sau đó, bạn sẽ có thể xóa thư mục bằng cách sử dụng index.delete() Untested!

Chỉ là một lớp lót.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

Tài liệu tại đây

Điều này hoạt động và mặc dù có vẻ không hiệu quả nếu bỏ qua kiểm tra thư mục, nhưng không phải vậy: kiểm tra diễn ra ngay lập tức trong listFiles().

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

Cập nhật, để tránh các liên kết tượng trưng sau:

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

Tôi thích giải pháp này trên java 8:

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

Từ trang web này: http://www.baeldung.com/java-delete-directory

Trong JDK 7, bạn có thể sử dụng Files.walkFileTree()và Files.deleteIfExists()xóa một cây tệp. (Mẫu: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )

Trong JDK 6, một cách khả thi là sử dụng FileUtils.deleteQuietly từ Apache Commons để xóa một tệp, một thư mục hoặc một thư mục có tệp và thư mục con.

Sử dụng Apache Commons-IO, nó đang theo sau một lớp lót:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

Đây là (một chút) hiệu suất hơn FileUtils.deleteDirectory.

Như đã đề cập, Java không thể xóa một thư mục chứa tệp, vì vậy trước tiên hãy xóa các tệp và sau đó là thư mục.

Đây là một ví dụ đơn giản để làm điều này:

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

Hoặc là:

FileUtils.forceDelete(new File(destination));

Phiên bản đệ quy cơ bản của tôi, hoạt động với các phiên bản cũ hơn của JDK:

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

Đây là giải pháp tốt nhất cho 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;
            }
        });
    }
}

Ổi 21+ để giải cứu. Chỉ sử dụng nếu không có liên kết tượng trưng nào trỏ ra khỏi thư mục để xóa.

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

(Câu hỏi này đã được Google lập chỉ mục tốt, vì vậy những người khác sử dụng Guava có thể rất vui khi tìm thấy câu trả lời này, ngay cả khi nó là thừa với các câu trả lời khác ở nơi khác.)

Tôi thích giải pháp này nhất. Nó không sử dụng thư viện của bên thứ 3, thay vào đó nó sử dụng NIO2 của 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;
        }
    });
}

Một lựa chọn nữa là sử dụng org.springframework.util.FileSystemUtilsphương pháp có liên quan của Spring sẽ xóa một cách đệ quy tất cả nội dung của thư mục.

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

Điều đó sẽ thực hiện công việc!

Trong này

index.delete();

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

bạn đang gọi

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

sau

index.delete();

Đây có nghĩa là bạn đang tạo ra các tập tin một lần nữa sau khi xóa File.Delete () trả về một value.So boolean nếu bạn muốn kiểm tra sau đó làm System.out.println(index.delete());nếu bạn nhận được truesau đó phương tiện này mà tập tin bị xóa

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
               }




        }

từ các bình luận đưa ra bên dưới, câu trả lời được cập nhật như thế này

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

Nếu bạn có các thư mục con, bạn sẽ thấy rắc rối với các câu trả lời Cemron. vì vậy bạn nên tạo một phương thức hoạt động như sau:

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

Bạn có thể sử dụng FileUtils.deleteDirectory . JAVA không thể xóa các màn hình đầu tiên không trống bằng File.delete () .

directry không thể xóa đơn giản nếu nó có các tệp, vì vậy bạn có thể cần phải xóa các tệp bên trong trước và sau đó là thư mục

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

Bạn có thể thực hiện cuộc gọi đệ quy nếu tồn tại các thư mục con

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

chúng ta có thể sử dụng spring-corephụ thuộc;

boolean result = FileSystemUtils.deleteRecursively(file);

Hầu hết các câu trả lời (thậm chí gần đây) tham chiếu đến các lớp JDK đều dựa vào File.delete()nhưng đó là một API thiếu sót vì hoạt động có thể không thành công.
Các java.io.File.delete()tiểu bang tài liệu hướng dẫn phương pháp:

Lưu ý rằng java.nio.file.Fileslớp định nghĩa deletephương thức ném IOExceptionmột tệp khi không thể xóa tệp. Điều này rất hữu ích cho việc báo cáo lỗi và chẩn đoán lý do tại sao không thể xóa tệp.

Để thay thế, bạn nên ưu tiên Files.delete(Path p) ném một IOExceptionthông báo lỗi.

Mã thực tế có thể được viết như:

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

bạn có thể thử như sau

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

Nếu có các thư mục con bên trong thư mục của bạn, bạn có thể cần phải xóa chúng một cách đệ quy.

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

    }

Hoạt động như một sự quyến rũ. Đối với cả thư mục và tệp. Salam :)

Xóa nó khỏi phần khác

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

Một số câu trả lời trong số này có vẻ dài không cần thiết:

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

Hoạt động cho các thư mục con quá.

Bạn có thể sử dụng chức năng này

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