因工作中需要根据任意父级节点查找到树形节点下的根节点信息，所以写了下面一个demo方便自己需要时的查看以及需要的人参考

• 一共两个类
  • TreeNode 使用了lombok插件
  • TreeNodeTest
• 主要的逻辑都在TreeNodeTest中 如果有错误的地方，还望留言评论，感谢

TreeNode

@Data
@AllArgsConstructor
public class TreeNode {
     * 节点ID
    private String id;
     * 父级ID
    private String parentId;
     * 节点名称
    private String name;
TreeNodeTest
 
 * 测试类
 * 此方法建议数据量少的情况使用 或者 此数据很少变动并且加入到缓存中
public class TreeNodeTest {
    public static void main(String[] args) {
         *                                0
         *                          /           \
         *                        123           130
         *                      /    \        /     \
         *                    124   125      131     132
         *                  /   \   /  \     /  \    /  \
         *                 126 127 128 129  133 134 135 136
         * 只支持 节点路径长度必须一致的情况下才可以
         * 此Demo可以实现 根据0 获取到[126 127 128 129 133 134 135 136]
         * 				根据123 获取到[126 127 128 129]
         * 注：比如 126 127节点没有  此时获取到的0根节点 就会出现 [124 128 129 133 134 135 136]
        TreeNode treeNode = new TreeNode("123","0","北京");
        TreeNode treeNode1 = new TreeNode("124","123","丰台区");
        TreeNode treeNode2 = new TreeNode("125","123","海淀区");
        TreeNode treeNode3 = new TreeNode("126","124","丰台区丰台科技园");
        TreeNode treeNode4 = new TreeNode("127","124","丰台区丰台南路");
        TreeNode treeNode5 = new TreeNode("128","125","海淀区中关村");
        TreeNode treeNode6 = new TreeNode("129","125","海淀区海淀公园");
        TreeNode treeNode7 = new TreeNode("130","0","上海");
        TreeNode treeNode8 = new TreeNode("131","130","徐汇区");
        TreeNode treeNode9 = new TreeNode("132","130","虹口区");
        TreeNode treeNode10 = new TreeNode("133","131","徐汇区龙华寺");
        TreeNode treeNode11 = new TreeNode("134","131","徐汇区天主教堂");
        TreeNode treeNode12 = new TreeNode("135","132","虹口区虹口足球场");
        TreeNode treeNode13 = new TreeNode("136","132","虹口区鲁迅公园");
        List<TreeNode> treeNodes = new LinkedList<>();
        treeNodes.add(treeNode);
        treeNodes.add(treeNode1);
        treeNodes.add(treeNode2);
        treeNodes.add(treeNode3);
        treeNodes.add(treeNode4);
        treeNodes.add(treeNode5);
        treeNodes.add(treeNode6);
        treeNodes.add(treeNode7);
        treeNodes.add(treeNode8);
        treeNodes.add(treeNode9);
        treeNodes.add(treeNode10);
        treeNodes.add(treeNode11);
        treeNodes.add(treeNode12);
        treeNodes.add(treeNode13);
        // 按照父级ID分组
        Map<String,List<TreeNode>> groupByParentIdMap = treeNodes.stream()
                .collect(Collectors.groupingBy(TreeNode::getParentId));
        // 存放 0:对应的所有根节点ID数据
        Set<String> topToLowerChildIdSet = new HashSet<>();
        // 取出顶级数据(也就是父级ID为0的数据  当然顶层的父级ID也可以自定义  这里只是演示  所以给了0)
        List<TreeNode> topTreeNodes = groupByParentIdMap.get("0");
        for(TreeNode node : topTreeNodes){
            getMinimumChildIdArray(groupByParentIdMap,node.getId(),topToLowerChildIdSet);
        System.out.println("0节点下所有的根节点数据集合:" + topToLowerChildIdSet.toString());
    * 根据父级节点获取最低层次 那一级的节点数据
     *          1
     *        /   \
     *       2     3
     *      / \   / \
     *     4  5  6  7
     * 上面的树形结构调用此方法  根据1 可以获取到  [4 5 6 7]
     *                        根据3 可以获得到  [6 7]
     * @param groupByParentIdMap 所有的元素集合(根据父级ID进行了分组) 分组方法可以使用lambda 如下:
     *                           Map<String, List<Person>> peopleByCity = personStream.collect(Collectors.groupingBy(Person::getCity));
     * @param pid 父级ID
     * @param topToLowerChildIdSet 存储最深根节点的数据集合
    public static Set<String> getMinimumChildIdArray(Map<String,List<TreeNode>> groupByParentIdMap,
                                                     String pid, Set<String> topToLowerChildIdSet){
        // 存放当前pid对应的所有根节点ID数据
        Set<String> currentPidLowerChildIdSet = new HashSet<>();
        // 获取当前pid下所有的子节点
        List<TreeNode> childTreeNodes = groupByParentIdMap.get(pid);
        if(CollUtil.isEmpty(childTreeNodes)){
            return null;
        for(TreeNode treeNode : childTreeNodes){
            Set<String> lowerChildIdSet = getMinimumChildIdArray(groupByParentIdMap,treeNode.getId(),currentPidLowerChildIdSet);
            if(CollUtil.isEmpty(lowerChildIdSet)){
                // 如果返回null  表示当前遍历的treeNode节点为最底层的节点
                currentPidLowerChildIdSet.add(treeNode.getId());
        System.out.println("当前父级ID："+ pid + "下所有的根节点数据:" + currentPidLowerChildIdSet.toString());
        // 把当前获取到的根节点数据 一并保存到上一个节点父级ID集合中
        topToLowerChildIdSet.addAll(currentPidLowerChildIdSet);
        return currentPidLowerChildIdSet;
运行后的结果：
 
                                    Java中获取树的末节点的方法有很多种。
一种方法是使用递归，遍历整棵树，找到最后一个叶子节点。
下面是一个示例代码，这个示例使用了 Java 的内置类 java.util.TreeMap：
import java.util.TreeMap;
public class TreeExample {
    public static void main(String[] args) {
    @RequestMapping("/list/tree")
    public R list(){
        List<CategoryEntity> entities=categoryService.listWithTree();
        return R.ok().put("data", entities);
select org_id from (
 select t1.org_id,
 if(find_in_set(parent_id, @pids) > 0, @pids := concat(@pids, ',', org_id), 0) as ischild
 from (
    select org_id,parent_id from olt_organization t
                                    在日常的开发工作中，我们经常会遇到需要返回树结构的情况，在此记录下一般的处理方式。树结构存在上下级关系，一般子节点会保存父节点的ID（parentId)，很多人会采用递归的方式去处理，但通过map，两次循环遍历的办法，可以不用递归即可实现返回树结构。
                                    我可以帮助你写一个简单的程序来获取最后一层树形结构的 ID，你需要自己提供树形结构的数据结构。这里是一个使用 Python 的例子：
def get_last_layer_ids(tree):
    if tree is None:
        return []
    if len(tree.children) == 0:
        return [tree.id]
    ids...
                                    // 仅仅查出含有msg的节点,如果有上层节点就包含上层节点,但不包含其节点的子节点
    public static void getSearchNode(String msg, OrgDto root, OrgDto out) {
        boolean isSetFatherNodeValue = false;
        // 节点包含 msg中的信息,就赋值
        String v = root.getName();
        if (!v.isEmpty()...