Как рекурсивно выполнить итерацию списка при сравнении условий с использованием потока java8

Question

У меня есть два набора json, которые состоят из рекурсивных детей.Я хочу найти последнего потомка в этом списке, который будет содержать «код», я хочу найти все «кодовые» значения из этого jsons.

Sample1:

{
    "totalSize": 1,
    "data": [
        {
            "level": "sites",
            "children": [
                {
                    "level": "sites",
                    "children": [
                        {
                            "level": "segments",
                            "children": [
                                {
                                    "level": "assets",
                                    "code": "1"
                                },
                                {
                                    "level": "assets",
                                    "code": "2"
                                },
                                {
                                    "level": "assets",
                                    "code": "3"
                                },
                                {
                                    "level": "assets",
                                    "code": "4"
                                },
                                {
                                    "level": "assets",
                                    "code": "5"
                                },
                                {
                                    "level": "assets",
                                    "code": "6"
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    ]
}

Sample2:

{
    "totalSize": 1,
    "data": [
        {
            "level": "sites",
            "children": [
                {
                    "level": "segments",
                    "children": [
                        {
                            "level": "assets",
                            "code": "1"
                        },
                        {
                            "level": "assets",
                            "code": "2"
                        },
                        {
                            "level": "assets",
                            "code": "3"
                        },
                        {
                            "level": "assets",
                            "code": "4"
                        },
                        {
                            "level": "assets",
                            "code": "5"
                        },
                        {
                            "level": "assets",
                            "code": "6"
                        }
                    ]
                }
            ]
        }
    ]
}

Существуют следующие сущности:

public class HierarchyResponse {

    private Integer totalSize;
    private List<Data> data;

}

public class Data {

    private List<Children> children;
    private String level;

}

public class Children {

    private String level;
    private List<Children> children;
}

Я пытался, но безуспешно:

List<Children> children = response
    .getData()
    .get(0)
    .getChildren()
    .stream().filter(t -> t.getLevel().equalsIgnoreCase("assets"))
    .collect(Collectors.toList());

Answer 1

вы можете создать метод, который рекурсивно отображает детей

private static Stream<Children> toStream(Children children) {
    if (children != null) {
        return Stream.concat(Stream.of(children), children.getChildren().stream().flatMap(c -> toStream(c)));
    } else {
        return Stream.empty();
    }
}

и используйте его как

List<Children> children = response.getData().stream()
            .flatMap(d -> d.getChildren().stream())
            .flatMap(c -> toStream(c))
            .filter(t -> t.getLevel().equalsIgnoreCase("assets"))
            .collect(Collectors.toList());

например

Children b1as2 = new Children("assets", "2");
Children b1as1 = new Children("assets", "1");
Children b1seg1 = new Children("segments", "0", List.of(b1as1, b1as2));
Children b1s1 = new Children("sites", "0", List.of(b1seg1));
Children b1 = new Children("sites", "0", List.of(b1s1));

Data data = new Data(List.of(b1));

HierarchyResponse response = new HierarchyResponse(List.of(data));

напечатает [Children{level='assets', code='1'}, Children{level='assets', code='2'}]

Другое решение не использует Stream API

private static List<Children> findAssetsChildren(List<Children> children) {
    List<Children> result = new LinkedList<>();
    for(Children ch: children) {
        if(ch.getLevel().equals("assets")) {
            result.add(ch);
        }
        result.addAll(findAssetsChildren(ch.getChildren()));
    }
    return result;
}
//...
List<Children> children = findAssetsChildren(response.getData()
                             .get(0).getChildren());