java后端操作樹(shù)結(jié)構(gòu)的案例代碼

更新時(shí)間：2023年10月24日 08:53:41 作者：spiderMan1-1

這篇文章主要介紹了java后端操作樹(shù)結(jié)構(gòu),樹(shù)結(jié)構(gòu)的三種組裝方式(遞歸.雙層for循環(huán),map)，通過(guò)實(shí)例代碼介紹了使用遞歸查詢某個(gè)節(jié)點(diǎn)所在的樹(shù)結(jié)構(gòu)，需要的朋友可以參考下

一、樹(shù)結(jié)構(gòu)的三種組裝方式(遞歸.雙層for循環(huán),map)

（1）遞歸

普通遞歸方法

 public Result getBmsMenuList(UserSessionVO userSessionInfo) {
        // 查詢頂級(jí)節(jié)點(diǎn)菜單
        List<BmsMenuVO> bmsMenuVOList = bmsMenuDao.selectBmsMenuList(new BmsMenuQueryConditionVO());

        for (BmsMenuVO bmsMenuVO : bmsMenuVOList) {
            getBmsMenuListByRecursion(bmsMenuVO);
        }

        return Result.createWithModels(null, bmsMenuVOList);
    }

 private void getBmsMenuListByRecursion(BmsMenuVO bmsMenuVO) {
        List<BmsMenuVO> bmsMenuVOS = bmsMenuDao.selectBmsMenuList(new BmsMenuQueryConditionVO().setParentId(bmsMenuVO.getId()));
        if (CollectionUtils.isEmpty(bmsMenuVOS)) {
            return;
        }
        bmsMenuVO.setChildBmsMenuList(bmsMenuVOS);
        for (BmsMenuVO menuVO : bmsMenuVOS) {
            getBmsMenuListByRecursion(menuVO);
        }
}

stream流遞歸方法

//獲取父節(jié)點(diǎn)
List<TreeSelect> collect = trees.stream().filter(m -> m.getParentId() == 0).map(
    (m) -> {
        m.setChildren(getChildrenList(m, trees));
        return m;
    }
).collect(Collectors.toList());
 
    /**
     * 獲取子節(jié)點(diǎn)列表
     * @param tree
     * @param list
     * @return
     */
    public static List<TreeSelect> getChildrenList(TreeSelect tree, List<TreeSelect> list){
        List<TreeSelect> children = list.stream().filter(item -> Objects.equals(item.getParentId(), tree.getId())).map(
                (item) -> {
                    item.setChildren(getChildrenList(item, list));
                    return item;
                }
        ).collect(Collectors.toList());
        return children;
    }

（2）雙層for循環(huán)

// 查詢主節(jié)點(diǎn)
List<BmsMenuVO> bmsMenuVOList = bmsRoleMenuDao.getAllRoleMenuList(condition);

// 拼裝結(jié)果
 List<BmsMenuVO> bmsMenuTree = new ArrayList<>();
 for (BmsMenuVO bmsMenuVO : bmsMenuVOList) {
      // 根節(jié)點(diǎn)的父Id為null
      if (bmsMenuVO.getParentId() == null) {
                bmsMenuTree.add(bmsMenuVO);
      }
      for (BmsMenuVO menuVO : bmsMenuVOList) {
           if (menuVO.getParentId() != null && menuVO.getParentId().equals(bmsMenuVO.getId())) {
               if (CollectionUtils.isEmpty(bmsMenuVO.getChildBmsMenuList())) {
                        bmsMenuVO.setChildBmsMenuList(new ArrayList<>());
                }
                bmsMenuVO.getChildBmsMenuList().add(menuVO);
           }
       }
  }

  // 返回結(jié)果
 return Result.createWithModels(null, bmsMenuTree);

（3）map遍歷

 // 查詢所有節(jié)點(diǎn)
 List<BmsMenuVO> bmsMenuVOList = bmsRoleMenuDao.getAllRoleMenuList(condition);
       
 // 拼裝結(jié)果     
 List<BmsMenuVO> bmsMenuTree = new ArrayList<>();
 // 用來(lái)存儲(chǔ)節(jié)點(diǎn)的子元素map
 Map<Long, BmsMenuVO> childBmsMenuMap = new LinkedHashMap<>();
        for (BmsMenuVO menuVO : bmsMenuVOList) {
            childBmsMenuMap.put(menuVO.getId(), menuVO);
        }
        for (Long bmsMenuId : childBmsMenuMap.keySet()) {
            BmsMenuVO menuVO = childBmsMenuMap.get(bmsMenuId);
            Long parentId = menuVO.getParentId();
            if (parentId == null) {
                bmsMenuTree.add(menuVO);
            } else {
                BmsMenuVO parentMenuVO = childBmsMenuMap.get(parentId);
                if (parentMenuVO.getChildBmsMenuList() == null) {
                    parentMenuVO.setChildBmsMenuList(new ArrayList<>());
                }
                parentMenuVO.getChildBmsMenuList().add(menuVO);
          }
}

2、使用遞歸查詢某個(gè)節(jié)點(diǎn)所在的樹(shù)結(jié)構(gòu)

使用場(chǎng)景：當(dāng)我們得到一個(gè)樹(shù)形結(jié)構(gòu)數(shù)據(jù)時(shí)，可能需要在樹(shù)形結(jié)構(gòu)上對(duì)數(shù)據(jù)進(jìn)行篩選，例如通過(guò)文件夾（文件）名稱模糊查詢相關(guān)的文件夾并展現(xiàn)其父級(jí)。

缺點(diǎn)：需要查詢出完整的樹(shù)形結(jié)構(gòu)才能用作篩選，在數(shù)據(jù)量非常龐大的時(shí)候并不適用。

@Data
public class TreeDto {

   private String id;
   private String name;
   private List<TreeDto> subsetTreeDtoList;



   public TreeDto(String id,String name,List<TreeDto> subsetTreeDtoList){
       this.id = id;
       this.name = name;
       this.subsetTreeDtoList = subsetTreeDtoList;
   }
}

篩選

  /**
    * 樹(shù)形篩選查找
    * @param treeDtoList 樹(shù)形集合
    * @param idList 篩選條件(可以是其他條件)
    * @return 包含的節(jié)點(diǎn)數(shù)據(jù)
    */
   public static List<TreeDto> screenTree(List<TreeDto> treeDtoList, List<String> idList){
       //最后返回的篩選完成的集合
       List<TreeDto> screeningOfCompleteList = new ArrayList<>();
       if (listIsNotEmpty(treeDtoList) && listIsNotEmpty(idList)){
           for (TreeDto treeDto : treeDtoList){
               List<TreeDto> subsetList = treeDto.getSubsetTreeDtoList();
               //遞歸篩選完成后的返回的需要添加的數(shù)據(jù)
               TreeDto addTreeDto = getSubsetPmsPlanPo(treeDto,subsetList,idList);
               if (isNotEmpty(addTreeDto)){
                   screeningOfCompleteList.add(addTreeDto);
               }
           }
           return screeningOfCompleteList;
       }
       return null;
   }


   /**
    * 篩選符合的集合并返回
    * @param treeDto 樹(shù)形類
    * @param subsetTreeDtoList 子集集合
    * @param idList 篩選條件
    * @return 篩選成功的類
    */
   public static TreeDto getSubsetPmsPlanPo(TreeDto treeDto,List<TreeDto> subsetTreeDtoList,List<String> idList){
       //作為篩選條件的判斷值
       String id = treeDto.getId();
       //有子集時(shí)繼續(xù)向下尋找
       if (listIsNotEmpty(subsetTreeDtoList)){
           List<TreeDto> addTreeDtoList = new ArrayList<>();
           for (TreeDto subsetTreeDto : subsetTreeDtoList){
               List<TreeDto> subsetList = subsetTreeDto.getSubsetTreeDtoList();
               TreeDto newTreeDto = getSubsetPmsPlanPo(subsetTreeDto,subsetList,idList);
               //當(dāng)子集篩選完不為空時(shí)添加
               if (isNotEmpty(newTreeDto)){
                   addTreeDtoList.add(newTreeDto);
               }
           }
           //子集滿足條件篩選時(shí)集合不為空時(shí)，替換對(duì)象集合內(nèi)容并返回當(dāng)前對(duì)象
           if (listIsNotEmpty(addTreeDtoList)){
               treeDto.setSubsetTreeDtoList(addTreeDtoList);
               return treeDto;
               //當(dāng)前對(duì)象子集對(duì)象不滿足條件時(shí)，判斷當(dāng)前對(duì)象自己是否滿足篩選條件，滿足設(shè)置子集集合為空，并返回當(dāng)前對(duì)象
           }else if (listIsEmpty(addTreeDtoList) && idList.contains(id)){
               treeDto.setSubsetTreeDtoList(null);
               return treeDto;
           }else {
               //未滿足篩選條件直接返回null
               return null;
           }
       }else {
           //無(wú)子集時(shí)判斷當(dāng)前對(duì)象是否滿足篩選條件
           if (idList.contains(id)){
               return treeDto;
           }else {
               return null;
           }
       }
   }

   /**
    * 判斷集合為空
    * @param list 需要判斷的集合
    * @return 集合為空時(shí)返回 true
    */
   public static boolean listIsEmpty(Collection list){
       return  (null == list || list.size() == 0);
   }

   /**
    * 判斷集合非空
    * @param list 需要判斷的集合
    * @return 集合非空時(shí)返回 true
    */
   public static boolean listIsNotEmpty(Collection list){
       return !listIsEmpty(list);
   }

   /**
    * 判斷對(duì)象為null或空時(shí)
    * @param object 對(duì)象
    * @return 對(duì)象為空或null時(shí)返回 true
    */
   public static boolean isEmpty(Object object) {
       if (object == null) {
           return (true);
       }
       if ("".equals(object)) {
           return (true);
       }
       if ("null".equals(object)) {
           return (true);
       }
       return (false);
   }

   /**
    * 判斷對(duì)象非空
    * @param object 對(duì)象
    * @return 對(duì)象為非空時(shí)返回 true
    */
   public static boolean isNotEmpty(Object object) {
       if (object != null && !object.equals("") && !object.equals("null")) {
           return (true);
       }
       return (false);
   }

   public static void main(String[] args) {
       TreeDto treeDto1 = new TreeDto("1","A",new ArrayList<TreeDto>());
       TreeDto treeDto1_1 = new TreeDto("1.1","A-A",new ArrayList<TreeDto>());
       TreeDto treeDto1_2 = new TreeDto("1.2","A-B",new ArrayList<TreeDto>());
       TreeDto treeDto1_3 = new TreeDto("1.3","A-C",new ArrayList<TreeDto>());
       treeDto1.getSubsetTreeDtoList().add(treeDto1_1);
       treeDto1.getSubsetTreeDtoList().add(treeDto1_2);
       treeDto1.getSubsetTreeDtoList().add(treeDto1_3);

       TreeDto treeDto2 = new TreeDto("2","B",new ArrayList<TreeDto>());
       TreeDto treeDto2_1 = new TreeDto("2.1","B-A",new ArrayList<TreeDto>());
       TreeDto treeDto2_2 = new TreeDto("2.2","B-B",new ArrayList<TreeDto>());
       TreeDto treeDto2_3 = new TreeDto("2.3","B-C",new ArrayList<TreeDto>());
       TreeDto treeDto2_3_1 = new TreeDto("2.3.1","B-C-A",null);
       treeDto2.getSubsetTreeDtoList().add(treeDto2_1);
       treeDto2.getSubsetTreeDtoList().add(treeDto2_2);
       treeDto2.getSubsetTreeDtoList().add(treeDto2_3);
       treeDto2.getSubsetTreeDtoList().get(2).getSubsetTreeDtoList().add(treeDto2_3_1);

       String[] array = {"1.3","2.2","2.3.1"};
       List<String> idList = Arrays.asList(array);
       List<TreeDto> treeDtoList = new ArrayList<>();
       treeDtoList.add(treeDto1);
       treeDtoList.add(treeDto2);
       System.out.println(JSON.toJSONString(screenTree(treeDtoList,idList)));
   }
}

返回結(jié)果為