eliminar carpeta de java [duplicar]

Tengo algo como esto :

public static boolean deleteDirectory(File directory) {
    if(directory.exists()){
        File[] files = directory.listFiles();
        if(null!=files){
            for(int i=0; i<files.length; i++) {
                if(files[i].isDirectory()) {
                    deleteDirectory(files[i]);
                }
                else {
                    files[i].delete();
                }
            }
        }
    }
    return(directory.delete());
}

Prueba esto:

public static boolean deleteDir(File dir) 
{ 
  if (dir.isDirectory()) 
  { 
    String[] children = dir.list(); 
    for (int i=0; i<children.length; i++)
      return deleteDir(new File(dir, children[i])); 
  }  
  // The directory is now empty or this is a file so delete it 
  return dir.delete(); 
} 

Podría ser un problema con las carpetas anidadas. El código elimina las carpetas en el orden en que se encontraron, que es de arriba hacia abajo, que no funciona. Podría funcionar si primero inviertes la lista de carpetas.

Pero te recomiendo que uses una biblioteca como Commons IO para esto.

Encontré esta pieza de código más comprensible y funcional:

public static boolean deleteDir(File dir) {
    if (dir.isDirectory()) {
        String[] children = dir.list();
        for (int i = 0; i < children.length; i++) {
            boolean success = deleteDir(new File(dir, children[i]));
            if (!success) {
                return false;
            }
        }
    }

    return dir.delete(); // The directory is empty now and can be deleted.
}

Usando los archivos .El método deleteDirectory() puede ayudar a simplificar el proceso de eliminar el directorio y todo lo que está debajo de él recursivamente.

Marque esta pregunta

Escribí un método para esto hace algún tiempo. Elimina el directorio especificado y devuelve true si la eliminación del directorio se realizó correctamente.

/**
 * Delets a dir recursively deleting anything inside it.
 * @param dir The dir to delete
 * @return true if the dir was successfully deleted
 */
public static boolean deleteDirectory(File dir) {
    if(! dir.exists() || !dir.isDirectory())    {
        return false;
    }

    String[] files = dir.list();
    for(int i = 0, len = files.length; i < len; i++)    {
        File f = new File(dir, files[i]);
        if(f.isDirectory()) {
            deleteDirectory(f);
        }else   {
            f.delete();
        }
    }
    return dir.delete();
}

Está almacenando todos los (sub) archivos y carpetas recursivamente en una lista, pero con su código actual almacena la carpeta padre antes de almacenar los hijos. Y así intenta eliminar la carpeta antes de que esté vacía. Prueba este código:

   if(tempFile.isDirectory()) {
        // children first
        fetchCompleteList(filesList, folderList, tempFile.getAbsolutePath());
        // parent folder last
        folderList.add(tempFile.getAbsolutePath());
   }

El archivo javadoc para .borrar()

Booleano público delete ()

Elimina el archivo o directorio denotado por esta ruta abstracta. Si esta ruta > denota un directorio, entonces el directorio debe estar vacío para ser eliminado.

Así que una carpeta tiene que estar vacía o eliminarla fallará. Su código actualmente llena la lista de carpetas con la carpeta más importante primero, seguida de sus subcarpetas. Ya que iterar a través de la lista de la misma manera que intentará eliminar la carpeta superior antes de eliminar sus subcarpetas, esto fallará.

Cambiando estas líneas

    for(String filePath : folderList) {
        File tempFile = new File(filePath);
        tempFile.delete();
    }

A esto

    for(int i = folderList.size()-1;i>=0;i--) {
        File tempFile = new File(folderList.get(i));
        tempFile.delete();
    }

Debe hacer que su código elimine las subcarpetas primero.

La operación de eliminación también devuelve false cuando falla, por lo que puede verificar este valor para hacer algún manejo de errores si es necesario.

Primero debe eliminar el archivo de la carpeta , luego la carpeta.De esta manera llamarás recursivamente al método.

Eliminará una carpeta recursivamente

public static void folderdel(String path){
    File f= new File(path);
    if(f.exists()){
        String[] list= f.list();
        if(list.length==0){
            if(f.delete()){
                System.out.println("folder deleted");
                return;
            }
        }
        else {
            for(int i=0; i<list.length ;i++){
                File f1= new File(path+"\\"+list[i]);
                if(f1.isFile()&& f1.exists()){
                    f1.delete();
                }
                if(f1.isDirectory()){
                    folderdel(""+f1);
                }
            }
            folderdel(path);
        }
    }
}