如何使用Lambda收集列表列表中的屬性值？

Question

我有一個具有以下結構的對象：

public class CategoryDTO {

    @JsonProperty("id")
    private Long id;

    @JsonProperty("parentId")
    private Long parentId;

    @JsonProperty("name")
    private String nameCategory;

    @JsonInclude(JsonInclude.Include.NON_EMPTY)
    private ComissaoPadraoEntity comission;

    @JsonProperty("categories")
    private List<CategoriaDTO> subcategories;

我做這個方法：

public Map<Long, List<Long>> mapATreeOfCategories(List<CategoryDTO> categories) {
        Map<Long, List<Long>> treeCategories = categoires.stream()
                .collect(Collectors.toMap(c -> c.getId(),
                        v -> v.getCategories().stream()
                                .map(e -> e.getId()).collect(Collectors.toList())));
        return treeCategories;

我這里有兩個問題，第一個Te返回是這樣的：

"1813": [1827,1830,1839,1834,1706,1822,2239,1835,2400,3290,3355,3319],...

OBS：他們只將優先級作為鍵，將第二個鍵作為值。 它甚至考慮了第三級。

如果您看下面的結構，我需要這樣返回：

"1813":[1813]

"1827":[1827,1813]

"1830":[1830,1827,1813]

"1831":[1831,1830,1827,1813]



<!--Payload-->
      {
          "categories": [
            {
              "id": "1813",
              "parentId": null,
              "name": "Malas e Mochilas",
              "items": 12,
              "categories": [
                {
                  "id": "1827",
                  "parentId": "1813",
                  "name": "Conjuntos de Malas",
                  "items": 0,
                  "categories": [

                  ],
                  "attributes": null
                },
                {
                  "id": "1830",
                  "parentId": "1813",
                  "name": "Mochilas",
                  "items": 4,
                  "categories": [
                    {
                      "id": "1831",
                      "parentId": "1830",
                      "name": "Mochila Esportiva",
                      "items": 0,
                      "categories": [

                      ],

第二個，我知道這個對象只有三個級別，但是將來如果再有一個級別，我想防止這種情況。

我想知道是否可以使用lambda進行此方法，如何使用lambda進行一次搜索。 還是唯一的方法是使用每種結構的基礎？

謝謝你的幫助。

Answer 1

private void associarCategorias(List<CategoriaDTO> categorias, Map<Long, List<Long>> arvoreDeCategorias) {
        categorias.forEach(departamento -> {
            arvoreDeCategorias.put(departamento.getCodigoCategoria(), Arrays.asList(departamento.getCodigoCategoria()));

            if (!ObjectUtils.isEmpty(departamento.getSubCategorias()) || !departamento.getSubCategorias().isEmpty()) {
                departamento.getSubCategorias().forEach(categoria -> {
                    arvoreDeCategorias.put(categoria.getCodigoCategoria(),
                            Arrays.asList(categoria.getCodigoCategoria(), departamento.getCodigoCategoria()));

                    if (!ObjectUtils.isEmpty(categoria.getSubCategorias()) || !categoria.getSubCategorias().isEmpty()) {
                        categoria.getSubCategorias().forEach(subCategoria -> {
                            arvoreDeCategorias.put(subCategoria.getCodigoCategoria(),
                                    Arrays.asList(subCategoria.getCodigoCategoria(), categoria.getCodigoCategoria(), departamento.getCodigoCategoria()));
                        });
                    }
                    return;
                });
                return;
            }
            associarCategorias(departamento.getSubCategorias(), arvoreDeCategorias);
        });
    }

Answer 2

基本上，您正在尋找一種實現深度優先遍歷的東西，然后在進入下一個遞歸時吐出id堆棧。 最好使用常規遞歸（如果不太深入）或使用堆棧數據結構的迭代版本來實現，以在遍歷過程中保持id堆棧。

偽代碼：

final Map<Integer, List<Integer>> categoriesMaps(final JsonNode node, final Stack<Integer> parentIds, final Map<Integer, List<Integer>> dest) {
    dest.put(node.categoryId, new ArrayList<>(parentIds));
    parentIds.push(node.categoryId)
    for (final Node child : node.children()) {
        categoriesMaps(child, parentIds, dest);
    }
    parentIds.pop(); // removes node.categoryIds
}

我認為這不是lambda / stream的最佳用法，特別是如果最大深度在編譯時未知，並且在“葉子” ID之間可能有所不同。

也許用流完成此操作的最佳方法是創建自己的Spliterator，該分離器將生成所需的LeafIds-> parentIDStackList對流，然后將其收集到映射中（如果需要）。