layui 树状图展示信息 ， 下级单位案件数量总和等于上级单位数量，由下到上，一层层叠加

查询数据库返回的map类型各字段
map{
    id  :   //类别的唯一标识
    categoryName： //字段名称
    parentId:   //父级id
    count :   //本类别数量
    
}

public class  A{

   //参数code 代表需要查询的类别id
    public List<Map<String, Object>> table(String code) {
    //查询所有类别的数量
        List<Map> list = baseMapper.getList();
        List<Map<String, Object>> result = new ArrayList<>();
        //获取满足条件的类别
        List<Map> collect = list.stream()
                .filter(e -> Objects.equals(e.get("id").toString(),code))
                .collect(Collectors.toList());
                // 返回树状图
        List<Map<String, Object>> tree = getTree(list, result, collect);
        int sum=0;
        //返回带有数量总和的map集合
        return getTreeCount(tree,sum);
    }

    /**
     * 查找下级菜单
     * 将实体类格式转换成tree指定的数据格式
     * @param list   所有类别的集合
     * @param result  存放当前层类别集合
     * @param collect  需要查询的类别集合
     * @return
     */
    private List<Map<String, Object>> getTree(List<Map> list , List<Map<String, Object>> result, List<Map> collect){

        for (Map category : collect){
            Map<String, Object> map = new HashMap<>();
            map.put("id", category.get("id"));
            map.put("title", category.get("categoryName"));
            // 树状图是否展开
            map.put("spread",false);
            //查询满足条件的下级类别
            List<Map> collect1 = list.stream()
                .filter(cate -> Objects.equals(cate.get("parentId").toString(),category.get("id").toString()))
                .collect(Collectors.toList());
            //判断是否有下级
            if (CollectionUtils.isEmpty(collect1)) {
                map.put("count", category.get("count"));
                //表示没有下级
                map.put("state",1);
            }else {
                //表示有下级
                map.put("state",0);
            }
            List<Map<String, Object>> result1 = new ArrayList<>();
            map.put("children", getTree(list, result1,collect1));
            result.add(map);
        }
        return result;
    }

     /**
     * 
     * @param tree 类别树状结构
     * @param sum 表示当前层的数量总和默认0
     * @return
     */
    private List<Map<String, Object>> getTreeCount(List<Map<String, Object>> tree,int sum){
        int sum1=0;
        for (Map<String, Object> map : tree) {
        //判断是否有下级
            if (Objects.equals(map.get("state").toString(),"0")) {
            //下级树状节点
                List<Map<String, Object>> list1= (List<Map<String, Object>>) map.get("children");
             //   下级带有总数的树状节点
                List<Map<String, Object>> count = getTreeCount(list1, sum1);
                //由于后面会把每层的总数重新封装成一个map，当作每层的第一个节点，返回给上一层
                for (Map<String, Object> stringObjectMap : count) {
                //判断子层节点中是否包含数量map
                    if(stringObjectMap.containsKey("sum")){
                        map.put("count",stringObjectMap.get("sum"));
                        sum1+=Integer.parseInt(map.get("count").toString());
                    }
                }
            }else {
                sum1+=Integer.parseInt(map.get("count").toString());
            }
        }
        //  把每层的总数重新封装成一个map，当作每层的第一个节点，返回给上一层
        if (!CollectionUtils.isEmpty(tree)) {
            Map<String, Object> map = tree.get(0);
            tree.remove(0);
            map.put("sum",sum1);
            tree.add(map);
        }
        return tree;
    }

经业务层处理返回给前端的map类型各字段
map{
    id  :   //类别的唯一标识
    title ： //字段名称
    count :   //下级案件总数量
    state：//是否有下级
    children：// 子节点集合
    sum:  // 本级案件总数量
}