Java：如何递归获取所有子目录？

Question

在调试 Late-hour-out-of-bound-recursive-function 之前：是否有获取子目录的命令？ giveMeSubDirs(downToPath)?

// WARNING: RECURSION out of bound or too much data
public HashSet<FileObject> getAllDirs(String path) {
  HashSet<FileObject> checkedDirs = new HashSet<FileObject>();
  HashSet<FileObject> allDirs = new HashSet<FileObject>();

  String startingPath = path;

  File fileThing = new File(path);
  FileObject fileObject = new FileObject(fileThing);

  for (FileObject dir : getDirsInDir(path)) {

    // SUBDIR

    while ( !checkedDirs.contains(dir) 
        && !(getDirsInDir(dir.getFile().getParent()).size() == 0)) {

      // DO NOT CHECK TOP DIRS if any bottom dir UNCHECKED!

      while ( uncheckedDirsOnLevel(path, checkedDirs).size() > 0) { 

        while (getDirsInDir(path).size() == 0 
            || (numberOfCheckedDirsOnLevel(path, checkedDirs)==getDirsInDir(path).size())) {
          allDirs.add(new FileObject(new File(path)));
          checkedDirs.add(new FileObject(new File(path)));

          if(traverseDownOneLevel(path) == startingPath )
            return allDirs;

          //get nearer to the root
          path = traverseDownOneLevel(path);
        }
        path = giveAnUncheckedDir(path, checkedDirs);

        if ( path == "NoUnchecked.") {
          checkedDirs.add(new FileObject( (new File(path)).getParentFile() ));
          break;
        }
      }
    }
  }
  return allDirs;
}

代码总结：

1. 尽可能深入目录树。当一个dir中没有dir时，停止，将dir放到set中，向上遍历。不要检查集合中的目录。
2. 如果到达起始路径，请停止并返回集合。
3. 重复步骤 1 和 2。

前提：目录结构是有限的，数据量很小。

Answer 1

不，Java 标准 API 中没有这样的功能。但是在Apache commons-io中有；如果您不想将其作为库包含，也可以look at the source code。

Answer 2

你可以通过以下sn-p获取所有子目录：

File file = new File("path");
File[] subdirs = file.listFiles(new FileFilter() {
    public boolean accept(File f) {
        return f.isDirectory();
    }
});

这只会获取直接子目录，要递归检索所有子目录，您可以编写：

List<File> getSubdirs(File file) {
    List<File> subdirs = Arrays.asList(file.listFiles(new FileFilter() {
        public boolean accept(File f) {
            return f.isDirectory();
        }
    }));
    subdirs = new ArrayList<File>(subdirs);

    List<File> deepSubdirs = new ArrayList<File>();
    for(File subdir : subdirs) {
        deepSubdirs.addAll(getSubdirs(subdir)); 
    }
    subdirs.addAll(deepSubdirs);
    return subdirs;
}

Answer 3

class DirFileFilter extends FileFilter {
  boolean accept(File pathname) {
    return pathname.isDirectory();
  }
}

DirFileFilter filter = new DirFileFilter();
HashSet<File> files = new HashSet<File>();

void rec(File root) {
  // add itself to the list
  files.put(root);
  File[] subdirs = root.list(filter);

  // bound of recursion: must return 
  if (subdirs.length == 0)
    return;
  else //this is the recursive case: can call itself
    for (File file : subdirs)
      rec(file);
}

Answer 4

另一个没有递归和字母顺序的版本。还使用 Set 来避免循环（在带有链接的 Unix 系统中存在问题）。

   public static Set<File> subdirs(File d) throws IOException {
        TreeSet<File> closed = new TreeSet<File>(new Comparator<File>() {
            @Override
            public int compare(File f1, File f2) {
                return f1.toString().compareTo(f2.toString());
            }
        });
        Deque<File> open = new ArrayDeque<File>();
        open.push(d);
        closed.add(d);
        while ( ! open.isEmpty()) {
            d = open.pop();
            for (File f : d.listFiles()) {
                if (f.isDirectory() && ! closed.contains(f)) {
                    open.push(f);
                    closed.add(f);
                }
            }
        }
        return closed;
    }

Answer 5

上面的示例代码缺少“);”在声明的最后。 正确的代码应该是：

  File file = new File("path");
  File[] subdirs = file.listFiles(new FileFilter() {
      public boolean accept(File f) {
          return f.isDirectory();
      }
  });

Answer 6

使用递归：

private void getAllSubFoldersInPath(File path)
{
    File[] files=path.listFiles();
    try {
        for(File file: files)
        {
            if(file.isDirectory())
            {
                System.out.println("DIRECTORY:"+file.getCanonicalPath());
                getAllSubFoldersInPath(file);
            }
            else
            {
                System.out.println("FILE: "+file.getCanonicalPath());   
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Answer 7

这是使用 Java 8 方法改进的代码。此代码将在递归基础上运行并查找目录，直到最后一个根目录。

List<File> findAllSubdirs(File file) {
    List<File> subdirs = Arrays.asList(file.listFiles(File::isDirectory));
    subdirs = new ArrayList<File>(subdirs);

    List<File> deepSubdirs = new ArrayList<File>();
    for(File subdir : subdirs) {
        deepSubdirs.addAll(findAllSubdirs(subdir)); 
    }
    subdirs.addAll(deepSubdirs);
    return subdirs;
}

如果您只想要直接子目录列表，请尝试使用下面的代码行..

List<File> subdirs = Arrays.asList(file.listFiles(File::isDirectory));

Answer 8

1. 从根文件中获取所有文件作为数组（@see listFiles）
2. 通过区分文件和目录对目录进行排序 (@see isDirectory)
3. 将第 1 步和第 2 步中的（过滤的）数组转换为列表
4. 将所有找到的目录添加到结果列表中
5. 对您在第 1 步中找到的每个目录文件重复该模式，结果列表会不断增加
6. 最后，返回结果列表

所有这些都融入了一些 lambda 魔法：

private static List<File> getAllSubDirectories(File root, List<File> result) {
    List<File> currentSubDirs = Arrays.asList(Objects.requireNonNull(root.listFiles(File::isDirectory), "Root file has to be directory"));
    result.addAll(currentSubDirs);
    currentSubDirs.forEach(file -> getAllSubDirectories(file, result));
    return result;
}

从根文件（应该是一个目录）和一个空列表开始。

注意：第 1 步和第 2 步可以与过滤器结合使用（@see listFiles(FileFilter filter)）