Cómo eliminar una carpeta con archivos usando Java

Quiero crear y eliminar un directorio usando Java, pero no funciona.

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

Java no puede eliminar carpetas con datos. Debe eliminar todos los archivos antes de eliminar la carpeta.

Usa algo como:

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

¡Entonces deberías poder eliminar la carpeta usando Sin index.delete() probar!

Solo una frase.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

Documentación aquí

Esto funciona, y aunque parece ineficaz omitir la prueba del directorio, no lo es: la prueba ocurre de inmediato en listFiles().

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

Actualizar, para evitar seguir enlaces simbólicos:

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

Prefiero esta solución en java 8:

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

Desde este sitio: http://www.baeldung.com/java-delete-directory

En JDK 7, puede usar Files.walkFileTree()y Files.deleteIfExists()para eliminar un árbol de archivos. (Ejemplo: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )

En JDK 6, una forma posible es utilizar FileUtils.deleteQuietly de Apache Commons, que eliminará un archivo, un directorio o un directorio con archivos y subdirectorios.

Usando Apache Commons-IO, sigue una línea:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

Esto es (ligeramente) más eficaz que FileUtils.deleteDirectory.

Como se mencionó, Java no puede eliminar una carpeta que contiene archivos, así que primero elimine los archivos y luego la carpeta.

Aquí hay un ejemplo simple para hacer esto:

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

O:

FileUtils.forceDelete(new File(destination));

Mi versión recursiva básica, trabajando con versiones anteriores de JDK:

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

Ésta es la mejor solución para 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+ al rescate. Úselo solo si no hay enlaces simbólicos que señalen fuera del directorio para eliminar.

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

(Esta pregunta está bien indexada por Google, por lo que otras personas que usen Guava podrían estar felices de encontrar esta respuesta, incluso si es redundante con otras respuestas en otros lugares).

Me gusta más esta solución. No utiliza una biblioteca de terceros, sino que utiliza NIO2 de 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;
        }
    });
}

Una opción más es utilizar el org.springframework.util.FileSystemUtilsmétodo relevante de Spring, que eliminará de forma recursiva todo el contenido del directorio.

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

¡Eso hará el trabajo!

En esto

index.delete();

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

estas llamando

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

después

index.delete();

Esto significa que está creando el archivo nuevamente después de eliminar File.delete () devuelve un valor booleano. Por lo tanto, si desea verificarlo, System.out.println(index.delete());si lo obtiene true, esto significa que el archivo se eliminó

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
               }




        }

de los comentarios que se dan a continuación, la respuesta actualizada es así

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

Si tiene subcarpetas, encontrará problemas con las respuestas de Cemron. entonces deberías crear un método que funcione así:

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

Puede utilizar FileUtils.deleteDirectory . JAVA no puede eliminar las carpetas no vacías con File.delete () .

directry no puede simplemente eliminar si tiene los archivos, por lo que es posible que primero deba eliminar los archivos internos y luego el directorio

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

Puede realizar llamadas recursivas si existen subdirectorios

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

podemos usar la spring-coredependencia;

boolean result = FileSystemUtils.deleteRecursively(file);

La mayoría de las respuestas (incluso recientes) que hacen referencia a clases de JDK se basan en, File.delete()pero esa es una API defectuosa ya que la operación puede fallar silenciosamente.
La java.io.File.delete()documentación del método dice:

Tenga en cuenta que la java.nio.file.Filesclase define el deletemétodo para lanzar un IOExceptionarchivo cuando no se puede eliminar. Esto es útil para informar errores y diagnosticar por qué no se puede eliminar un archivo.

Como reemplazo, debe favorecer Files.delete(Path p) que arroje un IOExceptionmensaje de error.

El código real podría escribirse como:

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

puedes intentar lo siguiente

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

Si hay subcarpetas dentro de su carpeta, es posible que deba eliminarlas de forma recursiva.

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

    }

Funciona de maravilla . Tanto para carpetas como para archivos. Salam :)

Eliminarlo de otra parte

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

Algunas de estas respuestas parecen innecesariamente largas:

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

También funciona para subdirectorios.

Puedes usar esta función

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