Question

在我的Android应用程序中，我将外部存储的所有路径填充到一个数组中。

我已阅读many linked posts有关此问题的原因，但我不知道如何处理它或阻止它在我正在使用的代码中发生。我也不理解Android可以处理的“递归限制”。

以下代码改编为from this source。

private final Locale loc = SupportedLanguages.isSupported();
private final String CACHE = "cache";
private final String TEMP = "temp";

@Override
protected Boolean doInBackground(Void... params) {

        final File fileList = Environment.getExternalStorageDirectory();

        final String absolutePath = Environment.getExternalStorageDirectory().getAbsolutePath();

        final File[] dirList = fileList.listFiles();

        final List<File> listDirs = Arrays.asList(dirList);

        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {

            final ArrayList<String> dirPath = new ArrayList<String>();
            final ArrayList<String> dirName = new ArrayList<String>();
            String fileName = "";

            for (final File startingDirectory : listDirs) {
                if (!startingDirectory.isFile() && startingDirectory.canRead() && !startingDirectory.isHidden()) {

                    final List<File> files = getFileListing(startingDirectory);

                    if (files != null) {

                        for (final File file : files) {

                            fileName = file.getPath().replaceAll(absolutePath, "").toLowerCase(loc).replaceAll("\\/", " ")
                                    .trim();
                            fileName = fileName.replaceAll(" +", " ");

                            dirName.add(fileName);
                            dirPath.add(file.toString());
                        }
                    }
                }
            }

        } 


    return true;
}

private List<File> getFileListing(File aStartingDir) {
    List<File> result = getFileListingNoSort(aStartingDir);

    if (result != null && !result.isEmpty()) {
        Collections.sort(result);
    }
    return result;
}

private List<File> getFileListingNoSort(File aStartingDir) {
    List<File> resultArray = new ArrayList<File>();
    File[] filesAndDirs = aStartingDir.listFiles();

    if (filesAndDirs != null && filesAndDirs.length > 0) {

        List<File> filesDirs = Arrays.asList(filesAndDirs);

        for (File file : filesDirs) {
            if (!file.isFile() && file.canRead() && !file.isHidden() && !file.getName().toLowerCase(loc).startsWith(CACHE)
                    && !file.getName().toLowerCase(loc).startsWith(TEMP)) {

                resultArray.add(file);
                List<File> deeperList = getFileListingNoSort(file);
                resultArray.addAll(deeperList);
            }
        }
    }

    return resultArray;
}

崩溃日志：

> Caused by: java.lang.StackOverflowError at
> java.lang.AbstractStringBuilder.append0(AbstractStringBuilder.java:145)
> at java.lang.StringBuilder.append(StringBuilder.java:216) at
> java.io.File.join(File.java:215) at java.io.File.<init>(File.java:157)
> at java.io.File.<init>(File.java:124) at
> java.io.File.filenamesToFiles(File.java:852) at
> java.io.File.listFiles(File.java:791) at
> com.mypackage.name.ll.a(Unknown Source) at
> com.mypackage.name.ll.a(Unknown Source) at
> com.mypackage.name.ll.a(Unknown Source) at
> com.mypackage.name.ll.a(Unknown Source) at
> com.mypackage.name.ll.a(Unknown Source) at
> com.mypackage.name.ll.a(Unknown Source) at
> com.mypackage.name.ll.a(Unknown Source) at
> com.mypackage.name.ll.a(Unknown Source) at
> com.mypackage.name.ll.a(Unknown Source)

依旧......

proguard映射：

com.mypackage.name.GenerateSubDirectoryList -> com.mypackage.name.ll:
java.util.List getFileListingNoSort(java.io.File) -> a

某处我需要计算递归并应用限制。但我不知道适用于Android或个别设备硬件的位置或限制？

提前感谢您的帮助。

Answer 1

计算递归很简单：只需在int方法中添加getFileListingNoSort参数，并在每次调用时递增值：

private List<File> getFileListingNoSort(File aStartingDir, int level) {
    List<File> resultArray = new ArrayList<File>();
    File[] filesAndDirs = aStartingDir.listFiles();

    if (level < MAX_LEVEL && filesAndDirs != null && filesAndDirs.length > 0) {

        List<File> filesDirs = Arrays.asList(filesAndDirs);

        for (File file : filesDirs) {
            if (!file.isFile() && file.canRead() && !file.isHidden() && !file.getName().toLowerCase(loc).startsWith(CACHE)
                    && !file.getName().toLowerCase(loc).startsWith(TEMP)) {

                resultArray.add(file);
                List<File> deeperList = getFileListingNoSort(file, ++level);
                resultArray.addAll(deeperList);
            }
        }
    }

    return resultArray;
}

但问题仍然存在：MAX_LEVEL的最佳值是什么，为什么它必然会循环。有问题的文件系统可能具有创建循环的符号链接。

Answer 2

Android在许多硬件上运行，其中大部分可能没有多少堆栈;而不是通过子目录递归，执行广度优先搜索，因此：

private List<File> getFileListingNoSort(File aStartingDir) 
{
    // assuming aStartingDir is a valid input
    List<File> dirsToSearch = new ArrayList<File>();
    dirsToSearch.add(aStartingDir);
    List<File> resultArray = new ArrayList<File>();
    do{
        File thisDir = dirsToSearch.remove(0);      
        List<File> filesDirs = Arrays.asList(thisDir.listFiles());

        for (File file : filesDirs) 
        {
            if (file.isDirectory())
            {
                dirsToSearch.add(file);
            }
             else if( file.canRead() && 
                      !file.isHidden() &&     
                      !file.getName().toLowerCase(loc).startsWith(CACHE) &&
                      !file.getName().toLowerCase(loc).startsWith(TEMP))
            {
                resultArray.add(file);              
            }
        }
    } while(false == dirsToSearch.isEmpty());
    return resultArray;
}

警告：我没有运行，甚至没有看到此代码是否编译。

但是想法是，维护一个目录列表，从你关心的目录开始，从该列表中删除第一个目录，将该目录中的文件添加到结果中（修改代码以将目录添加到如果你也想要目录，则为resultArray），将目录添加到要搜索的目录列表中，并继续直到目录列表为空。

如果你事先无法知道你需要走多远，或者你能走多远，那么递归是不好的。我不相信文件系统迭代是递归的合适位置，但这是我自己的看法。

java.lang.StackOverflowError递归目录

2 个答案: