如何使用 Java 删除文件夹

把它从其他部分移开

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

在这里

index.delete();


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

是你打来的

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

之后

index.delete();

这意味着在删除文件后将再次创建该文件 Delete () 返回一个布尔值。所以如果你想检查，那么如果你得到了 true就执行 System.out.println(index.delete());，这意味着文件被删除了

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
               }








        }

从下面给出的 评论，更新的答案是这样的

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

Java 无法删除包含数据的文件夹。必须在删除文件夹之前删除所有文件。

使用这样的东西:

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

然后您应该能够使用 index.delete()删除该文件夹 未经测试！

在 JDK7中，您可以使用 Files.walkFileTree()和 Files.deleteIfExists()来删除文件树(示例: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html)

在 JDK 6中，一种可能的方法是使用 Apache Commons 中的 静静地删除，它将删除包含文件和子目录的文件、目录或目录。

Directry 不能简单地删除文件，因此您可能需要先删除目录中的文件，然后再删除目录中的文件

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

如果你有子文件夹，你会发现与西蒙答案的麻烦。所以你应该创建一个这样的方法:

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

只是一句俏皮话。

import org.apache.commons.io.FileUtils;


FileUtils.deleteDirectory(new File(destination));

文件 给你

private void deleteFileOrFolder(File file){
try {
for (File f : file.listFiles()) {
f.delete();
deleteFileOrFolder(f);
}
} catch (Exception e) {
e.printStackTrace(System.err);
}
}

使用 Apache Commons-IO，它只有一行程序:

import org.apache.commons.io.FileUtils;


FileUtils.forceDelete(new File(destination));

这比 FileUtils.deleteDirectory的性能(稍微)高一些。

这很有效，虽然跳过目录测试看起来效率很低，但实际上并非如此: 测试立即在 listFiles()中进行。

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

更新，以避免以下符号链接:

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

我的基本递归版本，使用旧版本的 JDK:

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

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


}

像魔法一样工作。文件夹和文件。萨拉姆:)

您可以使用这个函数

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

我最喜欢这个解决方案，它不使用第三方库，而是使用 Java7的 二氧化氮。

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

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

如果存在子目录，则可以进行递归调用

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

番石榴21 + 拯救。只有在没有符号链接指出目录要删除时才使用。

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

(这个问题被谷歌很好地编入索引，所以其他使用番石榴的人可能会很高兴找到这个答案，即使它与其他地方的答案是多余的。)

其中一些答案似乎冗长得没有必要:

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

也适用于子目录。

我更喜欢 java 8的这个解决方案:

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

来自本网站: http://www.baeldung.com/java-delete-directory

我们可以使用 spring-core的依赖关系;

boolean result = FileSystemUtils.deleteRecursively(file);

大多数引用 JDK 类的答案(甚至最近的答案)都依赖于 File.delete()，但这是一个有缺陷的 API，因为操作可能无声无息地失败。
java.io.File.delete()方法文档指出:

请注意，java.nio.file.Files类将 delete方法定义为 当文件无法删除时抛出 IOException 错误报告并诊断文件无法删除的原因。

作为替换，您应该支持抛出带有错误消息的 IOException的 Files.delete(Path p)。

实际的代码可以这样写:

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

你可以使用 目录.JAVA 不能删除非空的文件夹与 Delete ()。

如前所述，爪哇咖啡无法删除包含文件的文件夹，因此首先删除文件，然后再删除该文件夹。

这里有一个简单的例子:

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

或者:

FileUtils.forceDelete(new File(destination));

另一种选择是使用 Spring 的 org.springframework.util.FileSystemUtils相关方法，它将递归地删除目录中的所有内容。

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

这样就行了！

2020年在这里:)

对于 Apache commons io FileUtils，与“纯”Java 变体相反，需要删除一个文件夹 不需要是空的。为了让您更好地了解情况，我在这里列出了一些变体，以下是出于各种原因的3个 可以投掷异常:

• CleanDirectory : 清理目录而不删除它
• 强制删除 : 删除一个文件。如果文件是一个目录，那么删除它和所有的子目录
• ForcDeleteOnExit : 计划在 JVM 退出时删除一个文件。如果文件是目录，删除它和所有子目录。不建议运行服务器，因为 JVM 可能不会很快退出..。

以下变体 从不抛球异常(即使文件为空!)

• 删除一个文件，从不抛出例外。如果它是一个目录，删除它和所有的子目录。

还有一件事要知道的是处理 象征性的联系，它会删除符号链接，而不是目标文件夹... 小心。

还要记住，删除一个大文件或文件夹可以是一个 阻塞操作很长一段时间... 因此，如果你不介意让它运行异步做(在一个后台线程通过执行器，例如)。

您还可以使用此选项删除包含子文件夹和文件的文件夹。

1. 首先，创建一个递归函数。

    private void recursiveDelete(File file){
   
   
   if(file.list().length > 0){
   String[] list = file.list();
   for(String is: list){
   File currentFile = new File(file.getPath(),is);
   if(currentFile.isDirectory()){
   recursiveDelete(currentFile);
   }else{
   currentFile.delete();
   }
   }
   }else {
   file.delete();
   }
   }
   

2. 然后，从初始函数使用 while 循环调用递归。

    private boolean deleteFolderContainingSubFoldersAndFiles(){
   
   
   boolean deleted = false;
   File folderToDelete = new File("C:/mainFolderDirectoryHere");
   
   
   while(folderToDelete != null && folderToDelete.isDirectory()){
   recursiveDelete(folderToDelete);
   }
   
   
   return deleted;
   }
   

这里有一个简单的方法:

public void deleteDirectory(String directoryPath)  {
new Thread(new Runnable() {
public void run() {
for(String e: new File(directoryPath).list()) {
if(new File(e).isDirectory())
deleteDirectory(e);
else
new File(e).delete();
}
}
}).start();
}

你可以试试这个

public static void deleteDir(File dirFile) {
if (dirFile.isDirectory()) {
File[] dirs = dirFile.listFiles();
for (File dir: dirs) {
deleteDir(dir);
}
}
dirFile.delete();
}

You can simply remove the directory which contains a single file or multiple files using the apache commons library.

梯级进口:

实现组: ‘ commons-io’，名称: ‘ commons-io’，版本: ‘2.5’

File file=new File("/Users/devil/Documents/DummyProject/hello.txt");
    

File parentDirLocation=new File(file.getParent);
    

//Confirming the file parent is a directory or not.
             

if(parentDirLocation.isDirectory){
    

    

//after this line the mentioned directory will deleted.
FileUtils.deleteDirectory(parentDirLocation);
   

}

List<File> temp = Arrays.asList(new File("./DIRECTORY").listFiles());
for (int i = 0; i < temp.size(); i++)
{
temp.get(i).delete();
}