I want to create and delete a directory using Java, but it isn't working.

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

10

30 Answers

Just a one-liner.

import org.apache.commons.io.FileUtils;
FileUtils.deleteDirectory(new File(destination));

Documentation here

8

Java isn't able to delete folders with data in it. You have to delete all files before deleting the folder.

Use something like:

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

Then you should be able to delete the folder by using index.delete()Untested!

5

This works, and while it looks inefficient to skip the directory test, it's not: the test happens right away in listFiles().

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

Update, to avoid following symbolic links:

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

4

I prefer this solution on java 8:

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

From this site:

8

In JDK 7 you could use Files.walkFileTree() and Files.deleteIfExists() to delete a tree of files. (Sample: )

In JDK 6 one possible way is to use FileUtils.deleteQuietly from Apache Commons which will remove a file, a directory, or a directory with files and sub-directories.

1

Using Apache Commons-IO, it is following one-liner:

import org.apache.commons.io.FileUtils;
FileUtils.forceDelete(new File(destination));

This is (slightly) more performant than FileUtils.deleteDirectory.

1

As mentioned, Java is unable to delete a folder containing files, so first delete the files and then the folder.

Here's a simple example to do this:

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

Or:

FileUtils.forceDelete(new File(destination));

One more choice is to use Spring's org.springframework.util.FileSystemUtils relevant method which will recursively delete all content of the directory.

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

That will do the job!

My basic recursive version, working with older versions of JDK:

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

1

This is the best solution for 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+ to the rescue. Use only if there are no symlinks pointing out of the directory to delete.

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

(This question is well-indexed by Google, so other people usig Guava might be happy to find this answer, even if it is redundant with other answers elsewhere.)

I like this solution the most. It does not use 3rd party library, instead it uses NIO2 of 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; } });
}

You can try this

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

2020 here :)

With Apache commons io FileUtils, contrary to the "pure" Java variants a folder does not need to be empty to be deleted. To give you a better overview I list the variants here, the following 3 may throw exceptions for various reasons:

• cleanDirectory: Cleans a directory without deleting it
• forceDelete: Deletes a file. If file is a directory, delete it and all sub-directories
• forceDeleteOnExit: Schedules a file to be deleted when JVM exits. If file is directory delete it and all sub-directories. Not recommended for running servers as JVM may not exit any time soon ...

The following variant never throws exceptions (even if the file is null !)

• deleteQuietly: Deletes a file, never throwing an exception. If it is a directory, delete it and all sub-directories.

One more thing to know is dealing with symbolic links, it will delete the symbolic link and not the target folder... be careful.

Also keep in mind that deleting a large file or folder can be a blocking operation for a good while ... so if you do not mind having it run async do it (in a background thread via executor for example).

In this

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

you are calling

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

after

index.delete();

This means that you are creating the file again after deletingFile.delete() returns a boolean value.So if you want to check then do System.out.println(index.delete()); if you get true then this means that file is deleted

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

from the comments given below,the updated answer is like this

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

0

If you have subfolders, you will find troubles with the Cemron answers. so you should create a method that works like this:

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

You can use FileUtils.deleteDirectory. JAVA can't delete the non-empty foldres with File.delete().

directry cannot simply delete if it has the files so you may need to delete the files inside first and then directory

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

0

we can use the spring-core dependency;

boolean result = FileSystemUtils.deleteRecursively(file);

Most of answers (even recent) referencing JDK classes rely on File.delete() but that is a flawed API as the operation may fail silently.
The java.io.File.delete() method documentation states :

Note that the java.nio.file.Files class defines the delete method to throw an IOException when a file cannot be deleted. This is useful for error reporting and to diagnose why a file cannot be deleted.

As replacement, you should favor Files.delete(Path p) that throws an IOException with a error message.

The actual code could be written such as :

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

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

Works like a Charm . For both folder and files . Salam :)

You can make recursive call if sub directories exists

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

You may also use this to delete a folder that contains subfolders and files.

1. Fist, create a recursive function.

    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. then, from your initial function use a while loop to call the recursive.

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

Here is a simple way to do it :

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

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

gradle import :

implementation group: 'commons-io', name: 'commons-io', version: '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();
}

Remove it from else part

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

0

Some of these answers seem unnecessarily long:

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

Works for sub directories too.

0

You can use this function

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

2

Your Answer

Sign up or log in

Sign up using Google Sign up using Facebook Sign up using Email and Password Submit

Post as a guest

Post Your Answer Discard

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy