lambda Java 8，如何映射一个列表，该列表是过滤操作的结果字段

Question

I have a catalog-like object hierarchy where every object has a name field.

class A {
    List<A> list;
    String name;
}

A{A{A{A...}AA},A{AAA},A{AAA}} // the depth is finite (~4)

I would like to provide a set of methods that return a list of child names (a a.getName()) of any parent element for a given name. So for level 1 I have

a.getAs().stream().map(a1 -> a1.getName()).collect(Collectors.toList());

Level 2 I have already troubles with:

a1.getAs().stream().filter(a2 -> a2.getName() == name)

now I want to access the As and map them to their names but I don't know how

EDIT: I have just realized that from the third level on it wouldn't be possible to find the list with just providing a single name. I would need a name for each level to be able to navigate to the node where the child list could be collected. On one hand I could keep all the objects in one Set and access them with an id. They would still have references to each other. On the other hand by not knowing the root element I couldn't get the structure right.

I think I have to rethink the problem.

Answer 1

It works only for one level of the hierarchy:

public List<A> getSubcategoriesByParentName(A category, String name) {
    return category.getSubcategories()
                   .stream()
                   .filter(subcategory -> subcategory.getName().equals(name))
                   .collect(Collectors.toList());
}

To achieve the next level, you could use a flatMap :

category.getSubcategories().stream()
        .flatMap(s -> s.getSubcategories().stream())
        .filter(s -> s.getName().equals(name))
        .collect(Collectors.toList());

As you can see, there is a need of recursion, it is not a work for Stream API.

Of course, being aware of the depth, we could access to all levels (by using a flatMap(s -> s.getSubcategories().stream()) several times), but it will look ugly.

Answer 2

You can do it like this:

public static List<String> getChildNames(A node, String... path) {
    Stream<A> s = node.getAs().stream();
    for(String name: path)
        s = s.filter(a -> a.getName().equals(name)).flatMap(a -> a.getAs().stream());
    return s.map(A::getName).collect(Collectors.toList());
}

but if the names beneath an A node are unique, you should consider maintaining a Map<String,A> , mapping from child name to actual child, instead of a List<A> . That would make traversing a path via unique name/ID as simple as node.get(name1).get(name2) . The logic of the method above would still be useful if you incorporate pattern matching, which doesn't need to have a unique result.

public static List<String> getChildNames(A node, String... pathPatterns) {
    Stream<A> s = node.getAs().stream();
    for(String namePattern: pathPatterns) {
        Pattern compiledPattern = Pattern.compile(namePattern);
        s = s.filter( a -> compiledPattern.matcher(a.getName()).find())
             .flatMap(a -> a.getAs().stream());
    }
    return s.map(A::getName).collect(Collectors.toList());
}