Java后端将查询数据组装成树结构

本文介绍了如何在Java后端通过LambdaQueryWrapper查询数据库数据,然后使用递归方法将其转换为树形结构,以展示物料分类。作者在CSDN博客中分享了查询数据并生成树形结构的具体代码片段。
摘要由CSDN通过智能技术生成





    public List<DictVo> getDictVoByPid(Long pId) {
        List<SysDict> sysDicts = sysDictMapper.selectList(new LambdaQueryWrapper<SysDict>()
                .eq(SysDict::getPid, pId).eq(SysDict::getIsDeleted, YesOrNoEnum.NO.getCode()));
        List<DictVo> dictVoList = new ArrayList<>();
        for(SysDict temp: sysDicts){
            DictVo dictVo  ;
            dictVo = new DictVo();
            BeanUtils.copyProperties(temp, dictVo);
            dictVoList.add(dictVo);
        }
        return dictVoList;

    }

    public List<DictVo> selectDictVoList() {
        List<SysDict> sysDicts = sysDictMapper.selectList(new LambdaQueryWrapper<SysDict>()
                .eq(SysDict::getIsDeleted, YesOrNoEnum.NO.getCode()));
        List<DictVo> dictVoList = new ArrayList<>();
        for(SysDict temp: sysDicts){
            DictVo dictVo = new DictVo();
            BeanUtils.copyProperties(temp, dictVo);
            dictVoList.add(dictVo);
        }
        return dictVoList;
    }


    /**
     * 获取物料分类树结构
     * @return
     */
    @Override
    public List<DictVo> getDictVoTree() {
        // 查询所有节点
        List<DictVo> voList = selectDictVoList();
        // 查询最高父节点
        List<DictVo> rootNode = getDictVoByPid(0L);
        // 设置子节点
        rootNode.forEach(info -> {
            List<DictVo> childrenList = this.getChildren(voList,info.getId());
            info.setChildrenDictVoList(childrenList);
        });
        return rootNode;
    }

    /**
     * 获取根据父节点ID获取子节点
     * @param allNode
     * @param parentId
     * @return
     */
    public List<DictVo> getChildren(List<DictVo> allNode, Long parentId){
        // 使用Linq匹配出传入父节点的下一级子节点
        List<DictVo> infoList =   allNode.stream().filter(t -> t.getPid().equals(parentId)).collect(Collectors.toList());
                //Linq.of(allNode).where(item->item.getMaterialtypeParent().equals(parentId)).toList();
        /**
         * 2023.02.03 更新
         * 这里可以用流处理,省去引入依赖
         */
        // List<BasMaterialType> basDischargeInfoList = allNode.stream().filter(item -> item.getMaterialtypeParent().equals(parentId)).collect(Collectors.toList());
        if (infoList.size()==0){
            return new ArrayList<>();
        }
        //递归下一级
        infoList.forEach(basDischargeInfo -> {
            basDischargeInfo.setChildrenDictVoList(getChildren(allNode,basDischargeInfo.getId()));
        });
        return infoList;
    }

Java后端将查询数据组装成树结构_查询数据并生成树-CSDN博客

  • 3
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
/** * 根据等级查询类目树 * * @param level * @return */ @Override public List queryCategoryTree(Integer level) { //查询当前级别下类目 List list = categoryDAO.list(level); //组装好的类目树,返回前端 List categoryTree = new ArrayList(); //所有类目 List allDTOList = new ArrayList(); if (CollectionUtils.isEmpty(list)) { return categoryTree; } for (CategoryDO categoryDO : list) { allDTOList.add(new CategoryTreeDTO().convertDOToDTO(categoryDO)); } //当前等级类目 categoryTree = allDTOList.stream().filter(dto -> level.equals(dto.getLevel())).collect(Collectors.toList()); for (CategoryTreeDTO categoryTreeDTO : categoryTree) { //组装类目为树结构 assembleTree(categoryTreeDTO, allDTOList,Constants.CATEGORY_MAX_LEVEL - level); } return categoryTree; } /** * 组装树 * * @param categoryTreeDTO * @param allList * @param remainRecursionCount 剩余递归次数 * @return */ public CategoryTreeDTO assembleTree(CategoryTreeDTO categoryTreeDTO, List allList, int remainRecursionCount) { remainRecursionCount--; //最大递归次数不超过Constants.CATEGORY_MAX_LEVEL-level次,防止坏数据死循环 if(remainRecursionCount < 0){ return categoryTreeDTO; } String categoryCode = categoryTreeDTO.getCategoryCode(); Integer level = categoryTreeDTO.getLevel(); //到达最后等级树返回 if (Constants.CATEGORY_MAX_LEVEL == level) { return categoryTreeDTO; } //子类目 List child = allList.stream().filter(a -> categoryCode.equals(a.getParentCode())).collect(Collectors.toList()); if (null == child) { return categoryTreeDTO; } categoryTreeDTO.setChildren(child); //组装子类目 for (CategoryTreeDTO dto : child) { assembleTree(dto, allList,remainRecursionCount); } return categoryTreeDTO; }
将List数据转换树形结构的基本思路是首先遍历List,将其中每个节点的父子关系建立起来,然后从根节点开始递归构建整个树形结构。 具体实现步骤如下: 1. 定义节点类,包含节点id、节点名称和子节点列表等属性。 ``` public class TreeNode { private String id; private String name; private List<TreeNode> children; // getter和setter方法 // ... } ``` 2. 遍历List,将每个节点的父子关系建立起来,可以使用Map来存储节点id和对应的节点对象,便于查找父节点。 ``` Map<String, TreeNode> map = new HashMap<>(); for (TreeNode node : list) { map.put(node.getId(), node); String parentId = node.getParentId(); if (parentId != null) { TreeNode parent = map.get(parentId); if (parent != null) { parent.getChildren().add(node); } } } ``` 3. 找到根节点,开始递归构建整个树形结构。 ``` public static TreeNode buildTree(List<TreeNode> list) { // 构建Map,方便查找节点 Map<String, TreeNode> map = new HashMap<>(); for (TreeNode node : list) { map.put(node.getId(), node); } // 找到根节点 TreeNode root = null; for (TreeNode node : list) { if (node.getParentId() == null) { root = node; break; } } // 从根节点开始递归构建整个树形结构 buildSubTree(root, map); return root; } private static void buildSubTree(TreeNode node, Map<String, TreeNode> map) { List<TreeNode> children = node.getChildren(); if (children == null) { return; } // 遍历子节点,递归构建子树 for (TreeNode child : children) { buildSubTree(child, map); } // 根据子节点的顺序重新排序 children.sort(Comparator.comparing(TreeNode::getName)); } ``` 以上就是将List数据转换树行结构的基本实现方法。需要注意的是,这里的代码只是一个简单的示例,实际情况下可能需要根据具体的业务需求进行修改和优化。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值