java 树形结构只返回每个节点最后一个

查询数据库所有的标签类(labelPO)得出数据,再组装成tree,然后使用lambda处理数据,使得只返回树结构每个节点的最后一个

实体类 标签类labelPO

@Data
@AllArgsConstructor
@NoArgsConstructor
public class LabelPO {

    private Long id;
    private String name;
    private Long partentId;
    private Long level;

    private List<LabelPO> childern;

    public LabelPO(Long id, String name, Long partentId, Long level) {
        this.id = id;
        this.name = name;
        this.partentId = partentId;
        this.level = level;
    }
}

数据处理

public class Blog {
    public static void main(String[] args) {
        // 构造数据
        final List<LabelPO> list = initData();
        // tree的临时变量
        List<LabelPO> childListsTemp = list;
        // 最终返回类
        List<LabelPO> childList=new ArrayList<>();

        // 把全量数据转为tree
        List<LabelPO> collect = list.stream()
                //找到所有最顶级的节点
                .filter(e -> e.getPartentId().equals(0L))
                查找顶级节点的所有子节点
                .map(e -> covert(e, childListsTemp))
                .collect(Collectors.toList());
        //System.out.println(JSON.toJSONString(collect));

        // 只返回tree每一个顶级的最后一个节点
        for (LabelPO listDTO : collect) {
            List<LabelPO> lists = get3Child(listDTO);
            childList.addAll(lists);
        }
        System.out.println(JSON.toJSONString(childList));
    }

    private static List<LabelPO> get3Child(LabelPO dto) {
        List<LabelPO> list = new ArrayList<>();
        //1.第一次拿到的是根节点
        List<LabelPO> children = dto.getChildern();
        //2.如果有子遍历根节点
        if (children != null && children.size() > 0) {
            for (LabelPO child : children) {
                List<LabelPO> child1 = get3Child(child);
                for (LabelPO centerTitleDto : child1) {
                    list.add(centerTitleDto);
                }
            }
        } else {
            list.add(dto);
        }
        return list;
    }


    /**
     * 返回当前节点的以及所有子节点
     *
     * @param nodeTree     当前节点
     * @param nodeTreeList 所有节点
     * @return
     */
    public static LabelPO covert(LabelPO nodeTree, List<LabelPO> nodeTreeList) {
        List<LabelPO> children = nodeTreeList.stream()
                //过滤出当前节点的下一级子节点
                .filter(subNodeTree -> subNodeTree.getPartentId().equals(nodeTree.getId()))
                //递归查找
                .map(subNodeTree -> covert(subNodeTree, nodeTreeList)).collect(Collectors.toList());
        nodeTree.setChildern(children);
        return nodeTree;
    }

    private static List<LabelPO> initData() {
        List<LabelPO> list = new ArrayList<>();
        list.add(new LabelPO(1L, "标签一", 0L, 1L));
        list.add(new LabelPO(2L, "标签二", 0L, 1L));
        list.add(new LabelPO(3L, "标签三", 1L, 2L));
        list.add(new LabelPO(4L, "标签四", 3L, 3L));
        list.add(new LabelPO(5L, "标签五", 2L, 2L));
        return list;
    }
}

组装的tree数据

[
    {
        "childern":[
            {
                "childern":[
                    {
                        "childern":[

                        ],
                        "id":4,
                        "level":3,
                        "name":"标签四",
                        "partentId":3
                    }
                ],
                "id":3,
                "level":2,
                "name":"标签三",
                "partentId":1
            }
        ],
        "id":1,
        "level":1,
        "name":"标签一",
        "partentId":0
    },
    {
        "childern":[
            {
                "childern":[

                ],
                "id":5,
                "level":2,
                "name":"标签五",
                "partentId":2
            }
        ],
        "id":2,
        "level":1,
        "name":"标签二",
        "partentId":0
    }
]

最终返回数据

[
    {
        "childern":[

        ],
        "id":4,
        "level":3,
        "name":"标签四",
        "partentId":3
    },
    {
        "childern":[

        ],
        "id":5,
        "level":2,
        "name":"标签五",
        "partentId":2
    }
]