it-swarm.com.de

Wie lösche ich einen ganzen Ordner und Inhalt?

Ich möchte, dass die Benutzer meiner Anwendung den DCIM-Ordner löschen können (der sich auf der SD-Karte befindet und Unterordner enthält).

Ist das möglich, wenn ja wie?

151
Beginner

Lassen Sie mich zunächst sagen, dass Sie den DCIM-Ordner nicht löschen können, da es sich um einen Systemordner handelt. Wenn Sie es manuell auf dem Telefon löschen, wird der Inhalt dieses Ordners gelöscht, nicht jedoch der DCIM-Ordner. Sie können den Inhalt mithilfe der folgenden Methode löschen:

Aktualisiert wie in den Kommentaren

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();
    }
}
273
chikka.anddev

Sie können Dateien und Ordner wie folgt rekursiv löschen:

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

    fileOrDirectory.delete();
}
491
teedyay

Wir können die Befehlszeilenargumente verwenden, um einen ganzen Ordner und dessen Inhalt zu löschen.

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

Beispiel für die Verwendung des obigen Codes:

deleteFiles("/sdcard/uploads/");
57
xinaxino

Ihr Ansatz ist für einen Ordner, der nur Dateien enthält, anständig. Wenn Sie jedoch nach einem Szenario suchen, das auch Unterordner enthält, ist eine Rekursion erforderlich

Sie sollten auch den Rückgabewert der Rückgabe erfassen, um sicherzustellen, dass Sie die Datei löschen dürfen

und enthalten

<uses-permission Android:name="Android.permission.WRITE_EXTERNAL_STORAGE" />

in deinem Manifest

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

verwenden Sie die Methode unten, um das gesamte Hauptverzeichnis zu löschen, das die Dateien und das zugehörige Unterverzeichnis enthält. Nachdem Sie diese Methode erneut aufgerufen haben, rufen Sie das delete () -Verzeichnis Ihres Hauptverzeichnisses auf.

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

In Kotlin können Sie die Erweiterung deleteRecursively() aus dem Paket kotlin.io verwenden

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

Es gibt viele Antworten, aber ich habe mich entschlossen, meine eigenen hinzuzufügen, weil es etwas anders ist. Es basiert auf OOP;)

Ich habe die Klasse DirectoryCleaner erstellt, die mir jedes Mal hilft, wenn ich ein Verzeichnis bereinigen muss.

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

    }
}

Es kann verwendet werden, um dieses Problem auf die nächste Weise zu lösen:

File dir = new File(Environment.getExternalStorageDirectory(), "your_directory_name");
new DirectoryCleaner(dir).clean();
dir.delete();
6
gio

Wenn Sie Dinge nicht rekursiv löschen müssen, können Sie Folgendes versuchen:

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

siehe Android.os.FileUtils, es wird auf API 21 ausgeblendet

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

Quelle: https://Android.googlesource.com/platform/frameworks/base/+/master/core/Java/Android/os/FileUtils.Java#414

4
edwardaa
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();
    }
}
4
Deep Verma

Das mache ich ... (knapp und getestet)

    ...
    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
    }
3
SoloPilot
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");
    }
}
3
JasonCheung

Einfache Möglichkeit, alle Dateien aus dem Verzeichnis zu löschen: 

Es ist eine generische Funktion zum Löschen aller Bilder aus dem Verzeichnis nur durch Aufruf 

deleteAllImageFile (Kontext);

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

Nach der Dokumentation :

Wenn dieser abstrakte Pfadname kein Verzeichnis angibt, gibt diese Methode null zurück.

Sie sollten also prüfen, ob listFilesnull ist, und nur fortfahren, wenn dies nicht der Fall ist

boolean deleteDirectory(File path) {
    if(path.exists()) {
        File[] files = path.listFiles();
        if (files == null) {
            return false;
        }
        for (File file : files) {
            if (file.isDirectory()) {
                deleteDirectory(file);
            } else {
                boolean wasSuccessful = file.delete();
                if (wasSuccessful) {
                    Log.i("Deleted ", "successfully");
                }
            }
        }
    }
    return(path.delete());
}
2
HB.

Hier ist eine nicht rekursive Implementierung, nur zum Spaß:

/**
 * 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);
        }
    }
}
1
PhilLab

Sicherster Code, den ich kenne:

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

Überprüft, ob die Datei vorhanden ist, behandelt Nullen und überprüft, ob das Verzeichnis tatsächlich gelöscht wurde

1
Gary Davies

Sie können das Verzeichnis nicht löschen, wenn es Unterverzeichnisse oder Dateien in Java enthält. Versuchen Sie diese einfache zweizeilige Lösung. Dadurch werden das Verzeichnis und die Wettbewerbe im Verzeichnis gelöscht.

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

Fügen Sie diese Zeile in die Abstufungsdatei ein und synchronisieren Sie das Projekt

compile 'org.Apache.commons:commons-io:1.3.2'  
1
Vigneswaran A
//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) {
    }
}

hier ist Ihre Lösung, es wird auch die Galerie aktualisiert.

0
Bilal Mustafa

Kurze koltin Version

fun File.deleteDirectory(): Boolean {
    return if (exists()) {
        listFiles()?.forEach {
            if (it.isDirectory) {
                it.deleteDirectory()
            } else {
                it.delete()
            }
        }
        delete()
    } else false
}
0
V. Kalyuzhnyu

Ein weiterer (moderner) Weg, um es zu lösen.

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

Unter Android seit 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();
        }
    }
}
0
Ch4rl3x

Löschen Sie den Ordner und alles darin auf Button klicken:

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

        }
    });
0
Krova

Ich habe dieses zwar gesetzt, aber es löscht einen Ordner mit beliebiger Verzeichnisstruktur.

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;

}

Hoffe das hilft.

0
user2288580