'How to delete a folder with files using Java
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();
}
}
Solution 1:[1]
Just a one-liner.
import org.apache.commons.io.FileUtils;
FileUtils.deleteDirectory(new File(destination));
Documentation here
Solution 2:[2]
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();
}
Solution 3:[3]
I prefer this solution on java 8:
Files.walk(pathToBeDeleted)
.sorted(Comparator.reverseOrder())
.map(Path::toFile)
.forEach(File::delete);
From this site: http://www.baeldung.com/java-delete-directory
Solution 4:[4]
In JDK 7 you could use Files.walkFileTree() and Files.deleteIfExists() to delete a tree of files. (Sample: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html)
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.
Solution 5:[5]
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.
Solution 6:[6]
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));
Solution 7:[7]
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!
Solution 8:[8]
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();
}
Solution 9:[9]
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;
}
});
}
}
Solution 10:[10]
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.)
Solution 11:[11]
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;
}
});
}
Solution 12:[12]
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();
}
Solution 13:[13]
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).
Solution 14:[14]
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 deleting
File.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();
}
}
Solution 15:[15]
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);
}
}
Solution 16:[16]
You can use FileUtils.deleteDirectory. JAVA can't delete the non-empty foldres with File.delete().
Solution 17:[17]
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();
}
}
Solution 18:[18]
we can use the spring-core dependency;
boolean result = FileSystemUtils.deleteRecursively(file);
Solution 19:[19]
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.Filesclass defines thedeletemethod to throw anIOExceptionwhen 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);
}
}
Solution 20:[20]
private void deleteFileOrFolder(File file){
try {
for (File f : file.listFiles()) {
f.delete();
deleteFileOrFolder(f);
}
} catch (Exception e) {
e.printStackTrace(System.err);
}
}
Solution 21:[21]
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 :)
Solution 22:[22]
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() );
}
}
Solution 23:[23]
You may also use this to delete a folder that contains subfolders and files.
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(); } }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; }
Solution 24:[24]
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();
}
Solution 25:[25]
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);
}
Solution 26:[26]
List<File> temp = Arrays.asList(new File("./DIRECTORY").listFiles());
for (int i = 0; i < temp.size(); i++)
{
temp.get(i).delete();
}
Solution 27:[27]
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");
Solution 28:[28]
Some of these answers seem unnecessarily long:
if (directory.exists()) {
for (File file : directory.listFiles()) {
file.delete();
}
directory.delete();
}
Works for sub directories too.
Sources
This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.
Source: Stack Overflow