android - que - ¿Cómo eliminar una carpeta completa y contenido?
que carpetas puedo eliminar de mi android (17)
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<File> 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);
}
}
}
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();
}
}
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
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
}
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();
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.
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();
}
}
}
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''
Podemos usar la 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,
deleteFiles("/sdcard/uploads/");
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();
}
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();
}
}
}
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 declaración para asegurarse de que se le permite eliminar el archivo
e incluir
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
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();
}
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;
}
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<children.length; i++) {
boolean success = deleteDir(new File(dir, children[i]));
if (!success) {
return false;
}
}
}
// The directory is now empty so delete it
return dir.delete();
}
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");
}
}
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();
}
}