¿Cómo eliminar una carpeta completa y contenido?

Quiero que los usuarios de mi aplicación puedan eliminar la carpeta DCIM (que se encuentra en la tarjeta SD y contiene subcarpetas).

¿Es esto posible? Si es así, ¿cómo?

Déjame decirte primero que no puedes eliminar la carpeta DCIM porque es una carpeta del sistema. A medida que lo elimine manualmente en el teléfono, eliminará el contenido de esa carpeta, pero no la carpeta DCIM. Puede eliminar su contenido utilizando el siguiente método:

Actualizado según los comentarios

File dir = new File(Environment.getExternalStorageDirectory()+"Dir_name_here"); if (dir.isDirectory()) { String[] children = dir.list(); for (int i = 0; i < children.length; i++) { new File(dir, children[i]).delete(); } } 

Puede eliminar archivos y carpetas recursivamente de esta manera:

 void deleteRecursive(File fileOrDirectory) { if (fileOrDirectory.isDirectory()) for (File child : fileOrDirectory.listFiles()) deleteRecursive(child); fileOrDirectory.delete(); } 

Podemos usar los argumentos de línea de comando para eliminar una carpeta completa y su contenido.

 public static void deleteFiles(String path) { File file = new File(path); if (file.exists()) { String deleteCmd = "rm -r " + path; Runtime runtime = Runtime.getRuntime(); try { runtime.exec(deleteCmd); } catch (IOException e) { } } } 

Ejemplo de uso del código anterior:

 deleteFiles("/sdcard/uploads/"); 

Su enfoque es decente para una carpeta que solo contiene archivos, pero si está buscando un escenario que también contenga subcarpetas, entonces se necesita recurrencia

También debe capturar el valor de retorno de la statement para asegurarse de que se le permite eliminar el archivo

e incluir

  

en tu manifiesto

 void DeleteRecursive(File dir) { Log.d("DeleteRecursive", "DELETEPREVIOUS TOP" + dir.getPath()); if (dir.isDirectory()) { String[] children = dir.list(); for (int i = 0; i < children.length; i++) { File temp = new File(dir, children[i]); if (temp.isDirectory()) { Log.d("DeleteRecursive", "Recursive Call" + temp.getPath()); DeleteRecursive(temp); } else { Log.d("DeleteRecursive", "Delete File" + temp.getPath()); boolean b = temp.delete(); if (b == false) { Log.d("DeleteRecursive", "DELETE FAIL"); } } } } dir.delete(); } 

utilice el método a continuación para eliminar todo el directorio principal que contiene archivos y su subdirectorio. Después de llamar a este método una vez más, llame al directorio delete () de su directorio principal.

 // For to Delete the directory inside list of files and inner Directory public static boolean deleteDir(File dir) { if (dir.isDirectory()) { String[] children = dir.list(); for (int i=0; i 

Si no necesita eliminar cosas recursivamente, puede intentar algo como esto:

 File file = new File(context.getExternalFilesDir(null), ""); if (file != null && file.isDirectory()) { File[] files = file.listFiles(); if(files != null) { for(File f : files) { f.delete(); } } } 

Hay muchas respuestas, pero decidí agregar la mía, porque es un poco diferente. Está basado en OOP;)

Creé la clase DirectoryCleaner , que me ayuda cada vez que necesito limpiar algún directorio.

 public class DirectoryCleaner { private final File mFile; public DirectoryCleaner(File file) { mFile = file; } public void clean() { if (null == mFile || !mFile.exists() || !mFile.isDirectory()) return; for (File file : mFile.listFiles()) { delete(file); } } private void delete(File file) { if (file.isDirectory()) { for (File child : file.listFiles()) { delete(child); } } file.delete(); } } 

Se puede usar para resolver este problema de la siguiente manera:

 File dir = new File(Environment.getExternalStorageDirectory(), "your_directory_name"); new DirectoryCleaner(dir).clean(); dir.delete(); 
 public static void deleteDirectory( File dir ) { if ( dir.isDirectory() ) { String [] children = dir.list(); for ( int i = 0 ; i < children.length ; i ++ ) { File child = new File( dir , children[i] ); if(child.isDirectory()){ deleteDirectory( child ); child.delete(); }else{ child.delete(); } } dir.delete(); } } 

mira android.os.FileUtils, es hide en la API 21

 public static boolean deleteContents(File dir) { File[] files = dir.listFiles(); boolean success = true; if (files != null) { for (File file : files) { if (file.isDirectory()) { success &= deleteContents(file); } if (!file.delete()) { Log.w("Failed to delete " + file); success = false; } } } return success; } 

Fuente: https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/os/FileUtils.java#414

En Kotlin puede usar la extensión deleteRecursively() del paquete kotlin.io

 val someDir = File("/path/to/dir") someDir.deleteRecursively() 

Esto es lo que hago … (breve y probado)

  ... deleteDir(new File(dir_to_be_deleted)); ... // delete directory and contents void deleteDir(File file) { if (file.isDirectory()) for (String child : file.list()) deleteDir(new File(file, child)); file.delete(); // delete child file or empty directory } 
 private static void deleteRecursive(File dir) { //Log.d("DeleteRecursive", "DELETEPREVIOUS TOP" + dir.getPath()); if (dir.isDirectory()) { String[] children = dir.list(); for (int i = 0; i < children.length; i++) { File temp = new File(dir, children[i]); deleteRecursive(temp); } } if (dir.delete() == false) { Log.d("DeleteRecursive", "DELETE FAIL"); } } 

Manera simple de borrar todo el archivo del directorio:

Es una función genérica para borrar todas las imágenes del directorio solo llamando

deleteAllImageFile (context);

 public static void deleteAllFile(Context context) { File directory = context.getExternalFilesDir(null); if (directory.isDirectory()) { for (String fileName: file.list()) { new File(file,fileName).delete(); } } } 

Aquí hay una implementación no recursiva, solo por diversión:

 /** * Deletes the given folder and all its files / subfolders. * Is not implemented in a recursive way. The "Recursively" in the name stems from the filesystem command * @param root The folder to delete recursively */ public static void deleteRecursively(final File root) { LinkedList deletionQueue = new LinkedList<>(); deletionQueue.add(root); while(!deletionQueue.isEmpty()) { final File toDelete = deletionQueue.removeFirst(); final File[] children = toDelete.listFiles(); if(children == null || children.length == 0) { // This is either a file or an empty directory -> deletion possible toDelete.delete(); } else { // Add the children before the folder because they have to be deleted first deletionQueue.addAll(Arrays.asList(children)); // Add the folder again because we can't delete it yet. deletionQueue.addLast(toDelete); } } } 

El código más seguro que conozco:

 private boolean recursiveRemove(File file) { if(file == null || !file.exists()) { return false; } if(file.isDirectory()) { File[] list = file.listFiles(); if(list != null) { for(File item : list) { recursiveRemove(item); } } } if(file.exists()) { file.delete(); } return !file.exists(); } 

Comprueba que el archivo existe, maneja nulos, comprueba que el directorio fue realmente eliminado

Le puse este, aunque está a punto de borrar una carpeta con cualquier estructura de directorio.

 public int removeDirectory(final File folder) { if(folder.isDirectory() == true) { File[] folderContents = folder.listFiles(); int deletedFiles = 0; if(folderContents.length == 0) { if(folder.delete()) { deletedFiles++; return deletedFiles; } } else if(folderContents.length > 0) { do { File lastFolder = folder; File[] lastFolderContents = lastFolder.listFiles(); //This while loop finds the deepest path that does not contain any other folders do { for(File file : lastFolderContents) { if(file.isDirectory()) { lastFolder = file; lastFolderContents = file.listFiles(); break; } else { if(file.delete()) { deletedFiles++; } else { break; } }//End if(file.isDirectory()) }//End for(File file : folderContents) } while(lastFolder.delete() == false); deletedFiles++; if(folder.exists() == false) {return deletedFiles;} } while(folder.exists()); } } else { return -1; } return 0; } 

Espero que esto ayude.

No puede eliminar el directorio si tiene subdirectorios o archivos en Java. Pruebe esta solución simple de dos líneas. Esto eliminará el directorio y los concursos dentro del directorio.

 File dirName = new File("directory path"); FileUtils.deleteDirectory(dirName); 

Agregue esta línea en el archivo gradle y sincronice el proyecto

 compile 'org.apache.commons:commons-io:1.3.2' 
 //To delete all the files of a specific folder & subfolder public static void deleteFiles(File directory, Context c) { try { for (File file : directory.listFiles()) { if (file.isFile()) { final ContentResolver contentResolver = c.getContentResolver(); String canonicalPath; try { canonicalPath = file.getCanonicalPath(); } catch (IOException e) { canonicalPath = file.getAbsolutePath(); } final Uri uri = MediaStore.Files.getContentUri("external"); final int result = contentResolver.delete(uri, MediaStore.Files.FileColumns.DATA + "=?", new String[]{canonicalPath}); if (result == 0) { final String absolutePath = file.getAbsolutePath(); if (!absolutePath.equals(canonicalPath)) { contentResolver.delete(uri, MediaStore.Files.FileColumns.DATA + "=?", new String[]{absolutePath}); } } if (file.exists()) { file.delete(); if (file.exists()) { try { file.getCanonicalFile().delete(); } catch (IOException e) { e.printStackTrace(); } if (file.exists()) { c.deleteFile(file.getName()); } } } } else deleteFiles(file, c); } } catch (Exception e) { } } 

esta es su solución, también actualizará la galería.

Otra forma (moderna) de resolverlo.

 public class FileUtils { public static void delete(File fileOrDirectory) { if(fileOrDirectory != null && fileOrDirectory.exists()) { if(fileOrDirectory.isDirectory() && fileOrDirectory.listFiles() != null) { Arrays.stream(fileOrDirectory.listFiles()) .forEach(FileUtils::delete); } fileOrDirectory.delete(); } } } 

En Android desde la API 26

 public class FileUtils { public static void delete(File fileOrDirectory) { if(fileOrDirectory != null) { delete(fileOrDirectory.toPath()); } } public static void delete(Path path) { try { if(Files.exists(path)) { Files.walk(path) .sorted(Comparator.reverseOrder()) .map(Path::toFile) // .peek(System.out::println) .forEach(File::delete); } } catch (IOException e) { e.printStackTrace(); } } } 

Eliminar la carpeta y todo lo que está dentro de ella, haga clic en el botón:

  my_button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { File folder_path = new File(Environment.getExternalStorageDirectory() + "/your_folder_name/"); if (file.exists()) { String deleteCmd = "rm -r " + folder_path; Runtime runtime = Runtime.getRuntime(); try { runtime.exec(deleteCmd); } catch (IOException ignored) { } } } });