Java: How to get only subdirectories name present at certain level?

Question

Here is my folder structure:

parent/
  child1/
    child1.1/
    child1.2/
  child2/
    child 2.1/
    child 2.2/
  child3/
    child 3.1/
    child 3.2/

How can I extract only the names of the third-level folders? (I haven't been able to find this online)

Output should be:

child1.1 ,child1.2 
child2.1 ,child2.2
child3.1 ,child3.2

I referenced Java: how to get all subdirs recursively? to find subdirectories.

Answer 1

To make level parametric I suggest code:

static public List<File> getDirs(File parent, int level){
    List<File> dirs = new ArrayList<File>();
    File[] files = parent.listFiles();
    if (files == null) return dirs; // empty dir
    for (File f : files){
        if (f.isDirectory()) {
             if (level == 0) dirs.add(f);
             else if (level > 0) dirs.addAll(getDirs(f,level-1));
        }
    }
    return dirs;
}

And call it:

List<File> l = getDirs(new File("/some/path"), 3);

Edit: I added verification in case of empty directory

Answer 2

Like Ole V.V. said. your task is actually simpler than the recursive walk the linked question discusses. You simply need to list the contents of each directory under parent, which might look something like this:

Path parent = Paths.get("parent");
try (DirectoryStream<Path> childStream = Files.newDirectoryStream(parent)) {
  for (Path child : childStream) {
    try (DirectoryStream<Path> subChildStream = Files.newDirectoryStream(child)) {
      for (Path subChild : subChildStream) {
        // or just print subChild to display the full path
        System.out.println(subChild.getFildName());
      }
    }
  }
}

You could also try Files.walkFileTree if you don't want to deal with try-with-resources blocks; setting the max-depth to 2 (since you're starting from parent) you can override preVisitDirectory() and only print paths two-deeper than parent.

Edit: The accepted answer uses the legacy java.io.File API. Java 7+ code should prefer the java.nio.file APIs, which my example uses.

Answer 3

I hope this will do the trick:

public List<File> getThirdLayer(File root) {
        List<File> thirdLayerFiles = new ArrayList<File>();
        for (File f : root.listFiles()) {
            if (f.isDirectory()) {
                for (File f2 : f.listFiles()) {
                    if (f2.isDirectory()) {
                        thirdLayerFiles.add(f2);
                    }
                }
            }
            return thirdLayerFiles;
        }
        return null;
    }

It will return a List of the thirdLayer of your structur!

Answer 4

Here’s an unpolished go.

    Path parent = FileSystems.getDefault().getPath("parent");
    Files.list(parent).forEach(child -> {
        try {
            System.out.println(Files.list(child).map(Path::getFileName).collect(Collectors.toList()));
        } catch (IOException e) {
            // TODO
        }
    });

It would print someting like

[child1.1, child1.2]
[child2.1, child2.2]
[child3.1, child3.2]

I hope you can tailor it to your needs.

Answer 5

I have tried my own solution based on comment by Ole V.V

public static void main(String[] args) throws IOException {

    String path = "D:/PT/Projects/current/1/bwb/2.1";
    File file = new File(path);
    List<File> level1folders = getDir(file); //level 1 folders
    level1folders = new ArrayList<File>(level1folders);
    List<File> level2folders = getSubdirs(level1folders); //level 2 folders
    List<File> level3folders = getSubdirs(level2folders);    ////level 3 folders

    //print
    for (File file2 : level3folders) {
        System.out.println(file2.getName());
    }

}

private static List<File> getDir(File file) {
    List<File> subdirs = Arrays.asList(file.listFiles(new FileFilter() {
        public boolean accept(File f) {
            return f.isDirectory();
        }
    }));
    return subdirs;
}
static List<File> getSubdirs(List<File> subdirs) {
    List<File> deepSubdirs = new ArrayList<File>();
    for(File subdir : subdirs) {
        deepSubdirs.addAll(getDir(subdir)); 
    }
    //subdirs.addAll(deepSubdirs);
    return deepSubdirs;
}

But krzydyn is good one! dimo414 is new to me. Thanks

Answer 6

You can also use the "walkFileTree"-Method in the Files-class.

Here a short example:

    Path startingDir = new File("parent").toPath();
    Integer depth = 2;
    EnumSet<FileVisitOption> opts = EnumSet.noneOf(FileVisitOption.class);
    FileVisitor<Path> finder = new FileVisitor<Path>() {
        @Override
        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
            if (attrs.isDirectory()
                    && dir.getNameCount() - startingDir.getNameCount() == depth) {
                System.out.println(dir.toString());
            }
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
            //ignore error in subtree
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
            return FileVisitResult.CONTINUE;
        }

    };
    Files.walkFileTree(startingDir, opts, depth + 1, finder);

Answer 7

If you want it to be recursive, you could use something like this:

public static void main(String[] args) {
    File file = new File(args[0]);
    List<File> results = new ArrayList<File>();
    getSubdirs(file, results, 0, 2);
    for (File f : results) {
        System.out.println(f.getAbsolutePath());
    }
}

public static List<File> getSubdirs(File file, List<File> results, int level, int targetlevel) {
    List<File> subdirs = Arrays.asList(file.listFiles(new FileFilter() {
        public boolean accept(File f) {
            return f.isDirectory();
        }
    }));
    subdirs = new ArrayList<File>(subdirs);
    if (level == targetlevel) results.addAll(subdirs);

    List<File> deepSubdirs = new ArrayList<File>();
    for(File subdir : subdirs) {
        deepSubdirs.addAll(getSubdirs(subdir, results, level + 1, targetlevel)); 
    }
    subdirs.addAll(deepSubdirs);
    return subdirs;
}

As you can see, I adapted the original method you referred too.

In this case, we create an empty list results and we start with level 0. Each time the recursive method is called, we add 1 to the level. We also pass a target level (in this case 2). We add all the results for which the level equals the targetlevel.

Note that this is much slower than the non-recursive methods shared by the other people (because you loop over every subdirectory), but it is more generic.