Android 如何删除整个文件夹和内容？

我希望我的应用程序的用户能够删除DCIM文件夹（位于SD卡上，包含子文件夹）

---

这是否可能，如果可能，如何实现？

首先让我告诉您，您无法删除DCIM文件夹，因为它是一个系统文件夹。当您在手机上手动删除它时，它将删除该文件夹的内容，但不会删除DCIM文件夹。您可以使用以下方法删除其内容：

根据评论更新

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

File dir=新文件（Environment.getExternalStorageDirectory（）+“dir\u name\u here”）；
if（dir.isDirectory（））
{
String[]children=dir.list（）；
for（int i=0；i

对于只包含文件的文件夹，您的方法是合适的，但是如果您正在寻找也包含子文件夹的场景，则需要递归

您还应该捕获返回的返回值，以确保允许您删除该文件

包括

在你的舱单上

void DeleteRecursive（文件目录）
{
d（“DeleteRecursive”、“DELETEPREVIOUS TOP”+dir.getPath（））；
if（dir.isDirectory（））
{
String[]children=dir.list（）；
for（int i=0；i

我们可以使用命令行参数删除整个文件夹及其内容

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

上述代码的示例用法：

deleteFiles("/sdcard/uploads/");

---

如果不需要递归删除内容，可以尝试以下方法：

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

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

    fileOrDirectory.delete();
}

---

您可以按如下方式递归删除文件和文件夹：

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

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

    fileOrDirectory.delete();
}

公共静态void deleteDirectory（文件目录）
{
if（dir.isDirectory（））
{
String[]children=dir.list（）；
for（int i=0；i

私有静态无效删除递归（文件目录）
{
//d（“DeleteRecursive”、“DELETEPREVIOUS TOP”+dir.getPath（））；
if（dir.isDirectory（））
{
String[]children=dir.list（）；
for（int i=0；i

我就是这么做的。。。（简洁且经过测试）

---

使用下面的方法删除包含文件的整个主目录及其子目录。调用此方法后，再次调用主目录的delete（）目录

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

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

    }
}

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

//用于删除文件列表和内部目录中的目录
公共静态布尔deleteDir（文件目录）{
if（dir.isDirectory（））{
String[]children=dir.list（）；
对于（inti=0；i有很多答案，但我决定添加我自己的答案，因为它有点不同。它基于OOP；）

我创建了类DirectoryCleaner，每当我需要清理一些目录时，它都会帮助我

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

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

    }
}

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

可通过下一种方式解决此问题：

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

参见android.os.FileUtils，它隐藏在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;
}

来源：
这里是一个非递归实现，只是为了好玩：

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

/**
*删除给定文件夹及其所有文件/子文件夹。
*名称中的“递归”源于文件系统命令
*@param root要递归删除的文件夹
*/
公共静态void递归删除（最终文件根）{
LinkedList deletionQueue=新建LinkedList（）；
deletionQueue.add（根目录）；
而（！deletionQueue.isEmpty（））{
最终文件toDelete=deletionQueue.removeFirst（）；
最终文件[]children=toDelete.listFiles（）；
if（children==null | | children.length==0）{
//这是一个文件或空目录->可以删除
toDelete.delete（）；
}否则{
//将子项添加到文件夹之前，因为必须先删除它们
deletionQueue.addAll（Arrays.asList（children））；
//再次添加文件夹，因为我们还不能删除它。
deletionQueue.addLast（toDelete）；
}
}
}
从目录中删除所有文件的简单方法：

这是一个只调用

deleteAllImageFile（上下文）

我把这个放在了它的位置上，它删除了一个具有任何目录结构的文件夹

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;

}

希望这有帮助。
我知道的最安全的代码：

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

检查文件是否存在，处理空值，检查目录是否已实际删除
如果该目录在Java中有子目录或文件，则无法删除该目录。请尝试此两行简单解决方案。这将删除该目录和目录内的竞争

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

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

    }
}

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

在gradle文件中添加此行并同步项目

compile 'org.apache.commons:commons-io:1.3.2'  

在Kotlin中，您可以使用
deleterecurively（）
扩展自
Kotlin.io
包

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

这是您的解决方案，它还将刷新图库。
另一种（现代）解决方法

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

从API 26开始在Android上运行

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

短科尔丁版本

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

更新

Kotlin stdlib函数

file.deleteRecursively()

根据报告：

如果这个摘要
public static boolean deleteAll(File file) {
    if (file == null || !file.exists()) return false;

    boolean success = true;
    if (file.isDirectory()) {
        File[] files = file.listFiles();
        if (files != null && files.length > 0) {
            for (File f : files) {
                if (f.isDirectory()) {
                    success &= deleteAll(f);
                }
                if (!f.delete()) {
                    Log.w("deleteAll", "Failed to delete " + f);
                    success = false;
                }
            }
        } else {
            if (!file.delete()) {
                Log.w("deleteAll", "Failed to delete " + file);
                success = false;
            }
        }
    } else {
        if (!file.delete()) {
            Log.w("deleteAll", "Failed to delete " + file);
            success = false;
        }
    }
    return success;
}

public static void deleteDirAndContents(@NonNull File mFile){
    if (mFile.isDirectory() && mFile.listFiles() != null && mFile.listFiles().length > 0x0) {
        for (File file : mFile.listFiles()) {
            deleteDirAndContents(file);
        }
    } else {
        mFile.delete();
    }
}

public static void deleteDirContents(@NonNull File mFile){
        if (mFile.isDirectory() && mFile.listFiles() != null && mFile.listFiles().length > 0x0) {
            for (File file : mFile.listFiles()) {
                deleteDirAndContents(file);
            }
        }
    }

if (!mFile.getAbsolutePath().equals(context.getCacheDir().getAbsolutePath())) {
    mFile.delete();
}

public static void clearAppCache(Context context){
        try {
            File cache = context.getCacheDir();
            FilesUtils.deleteDirContents(cache);
        } catch (Exception e){
            MyLogger.onException(TAG, e);
        }
    }

public static boolean deleteFolder(File removableFolder) {
        File[] files = removableFolder.listFiles();
        if (files != null && files.length > 0) {
            for (File file : files) {
                boolean success;
                if (file.isDirectory())
                    success = deleteFolder(file);
                else success = file.delete();
                if (!success) return false;
            }
        }
        return removableFolder.delete();
}