数据库的数据处理成树形结构

1、查询全量菜单（双层循环方式）

/**
     * 查询全量菜单
     *
     * @return
     */
    @Override
    public List<输出对象> querAllTree() {
        log.info("查询全量树");
        // 开始时间
        long stime = System.currentTimeMillis();
        //查询相对机构
        List<对象> OrgList = baseMapper.selectList(null);
        // 转换输出格式
        List<输出对象> resOrgList = OrgList.stream().map(u -> {
            输出对象 name = new 输出对象();
            BeanUtils.copyProperties(u, name);
            return name;
        }).collect(Collectors.toList());
        //返回的树形结构数据
        List<输出对象> trees = new ArrayList<>();
        //循环菜单树形数据
        for (输出对象menuTree : resOrgList) {
            //菜单级别为0，则是一级数据，根据实际情况判断可修改相关关联判断
            if ("00".equals(menuTree.getOrgClass())) {
                trees.add(menuTree);
                for (输出对象 it : resOrgList) {
                    //找出一级菜单下面的所有二级菜单，并加入到list中去
                    if (menuTree.getOrgCode().equals(it.getOrgSuperCode())) {
                        if (menuTree.getOrgChildrenMap() == null) {
                            menuTree.setOrgChildrenMap(new ArrayList<>());
                        }
                        menuTree.getOrgChildrenMap().add(it);
                    }
                }
            }
        }
        // 结束时间
        long etime = System.currentTimeMillis();
        log.info("机构数查询耗时：" + (etime - stime) + "毫秒");
        return trees;
    }

2、查询全量菜单（递归方式）

 /**
     * 使用递归方法建树
     * @param menuTrees  子节点集合
     * @return List<MenuTree>
     */
    public static List<输出对象> buildByRecursive(List<输出对象> menuTrees) {
        List<输出对象> trees = new ArrayList<>();
        for (输出对象 menuTree : menuTrees) {
           //菜单级别为00，则是一级数据，根据实际情况判断可修改相关关联判断
            if ("00".equals(menuTree.getOrgClass())) {
                trees.add(findChildren(menuTree,menuTrees));
            }
        }
        return trees;
    }

    /**
     * 递归查找子节点
     * @param menuTree  菜单数对象
     * @param menuTrees  子节点
     * @return MenuTree
     */
    private static 输出对象 findChildren(输出对象 menuTree,List<输出对象> menuTrees) {
        for (输出对象 it : menuTrees) {
            if(menuTree.getOrgCode().equals(it.getOrgSuperCode())) {
                if (menuTree.getChildren() == null) {
                    menuTree.setChildren(new ArrayList<输出对象>());
                }
                menuTree.getOrgChildrenMap().add(findChildren(it,menuTrees));
            }
        }
        return menuTree;
    }

3、全部菜单树（一次循环）

/**
     * 查询全量菜单
     *
     * @return
     */
    @Override
    public List<TOrgInfoTreeRes> querAllTree(TOrgInfoReq tOrgInfoReq) {
        log.info("查询全量树");
        String orgPath = tOrgInfoReq.getOrgCode();
        // 开始时间
        long stime = System.currentTimeMillis();
        //查询相对机构
        List<TOrgInfo> OrgList = tOrgInfoMapper.queryAllTree();
        // 转换输出格式
        List<TOrgInfoTreeRes> resOrgList = OrgList.stream().map(u -> {
            TOrgInfoTreeRes tOrgInfoTreeRes = new TOrgInfoTreeRes();
            BeanUtils.copyProperties(u, tOrgInfoTreeRes);
            return tOrgInfoTreeRes;
        }).collect(Collectors.toList());
        List<TOrgInfoTreeRes> treeList = new ArrayList<>();
        Map<String, TOrgInfoTreeRes> map = new LinkedHashMap<>();
        Map<String, TOrgInfoTreeRes> allMap = new HashMap<>();

        // 将数据组装为树状结构
        if (!CollectionUtils.isEmpty(resOrgList)) {
            for (TOrgInfoTreeRes temp : resOrgList) {
                TOrgInfoTreeRes node = new TOrgInfoTreeRes();
                if (temp.getOrgSuperCode() == null) {
                    BeanUtils.copyProperties(temp, node);
                    map.put(temp.getOrgCode(), node);
                } else {
                    if (allMap.containsKey(temp.getOrgSuperCode())) {
                        BeanUtils.copyProperties(temp, node);
                        TOrgInfoTreeRes parent = allMap.get(temp.getOrgSuperCode());
                        if (parent.getOrgChildrenMap() == null) {
                            parent.setOrgChildrenMap(new ArrayList<>());
                        }
                        parent.getOrgChildrenMap().add(node);
                    }
                }
                allMap.put(temp.getOrgCode(), node);
            }
        }
        for (Map.Entry<String, TOrgInfoTreeRes> entry : map.entrySet()) {
            treeList.add(entry.getValue());
        }
        // 结束时间
        long etime = System.currentTimeMillis();
        log.info("查询树耗时：" + (etime - stime) + "毫秒");
        return treeList;
    }