经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
java后端操作树结构 - spiderMan1-1
来源：cnblogs　　作者：spiderMan1-1　　时间：2023/10/25 10:13:42　　对本文有异议

一、树结构的三种组装方式(递归.双层for循环,map)

（1）递归
普通递归方法

  1.  public Result getBmsMenuList(UserSessionVO userSessionInfo) {
  2.         // 查询顶级节点菜单
  3.         List<BmsMenuVO> bmsMenuVOList = bmsMenuDao.selectBmsMenuList(new BmsMenuQueryConditionVO());
  5.         for (BmsMenuVO bmsMenuVO : bmsMenuVOList) {
  6.             getBmsMenuListByRecursion(bmsMenuVO);
  7.         }
  9.         return Result.createWithModels(null, bmsMenuVOList);
  10.     }
  12.  private void getBmsMenuListByRecursion(BmsMenuVO bmsMenuVO) {
  13.         List<BmsMenuVO> bmsMenuVOS = bmsMenuDao.selectBmsMenuList(new BmsMenuQueryConditionVO().setParentId(bmsMenuVO.getId()));
  14.         if (CollectionUtils.isEmpty(bmsMenuVOS)) {
  15.             return;
  16.         }
  17.         bmsMenuVO.setChildBmsMenuList(bmsMenuVOS);
  18.         for (BmsMenuVO menuVO : bmsMenuVOS) {
  19.             getBmsMenuListByRecursion(menuVO);
  20.         }
  21. }

stream流递归方法

  1. //获取父节点
  2. List<TreeSelect> collect = trees.stream().filter(m -> m.getParentId() == 0).map(
  3.     (m) -> {
  4.         m.setChildren(getChildrenList(m, trees));
  5.         return m;
  6.     }
  7. ).collect(Collectors.toList());
  8.  
  9.     /**
  10.      * 获取子节点列表
  11.      * @param tree
  12.      * @param list
  13.      * @return
  14.      */
  15.     public static List<TreeSelect> getChildrenList(TreeSelect tree, List<TreeSelect> list){
  16.         List<TreeSelect> children = list.stream().filter(item -> Objects.equals(item.getParentId(), tree.getId())).map(
  17.                 (item) -> {
  18.                     item.setChildren(getChildrenList(item, list));
  19.                     return item;
  20.                 }
  21.         ).collect(Collectors.toList());
  22.         return children;
  23.     }

（2）双层for循环

  1. // 查询主节点
  2. List<BmsMenuVO> bmsMenuVOList = bmsRoleMenuDao.getAllRoleMenuList(condition);
  4. // 拼装结果
  5.  List<BmsMenuVO> bmsMenuTree = new ArrayList<>();
  6.  for (BmsMenuVO bmsMenuVO : bmsMenuVOList) {
  7.       // 根节点的父Id为null
  8.       if (bmsMenuVO.getParentId() == null) {
  9.                 bmsMenuTree.add(bmsMenuVO);
  10.       }
  11.       for (BmsMenuVO menuVO : bmsMenuVOList) {
  12.            if (menuVO.getParentId() != null && menuVO.getParentId().equals(bmsMenuVO.getId())) {
  13.                if (CollectionUtils.isEmpty(bmsMenuVO.getChildBmsMenuList())) {
  14.                         bmsMenuVO.setChildBmsMenuList(new ArrayList<>());
  15.                 }
  16.                 bmsMenuVO.getChildBmsMenuList().add(menuVO);
  17.            }
  18.        }
  19.   }
  21.   // 返回结果
  22.  return Result.createWithModels(null, bmsMenuTree);

（3）map遍历

  1.  // 查询所有节点
  2.  List<BmsMenuVO> bmsMenuVOList = bmsRoleMenuDao.getAllRoleMenuList(condition);
  3.        
  4.  // 拼装结果     
  5.  List<BmsMenuVO> bmsMenuTree = new ArrayList<>();
  6.  // 用来存储节点的子元素map
  7.  Map<Long, BmsMenuVO> childBmsMenuMap = new LinkedHashMap<>();
  8.         for (BmsMenuVO menuVO : bmsMenuVOList) {
  9.             childBmsMenuMap.put(menuVO.getId(), menuVO);
  10.         }
  11.         for (Long bmsMenuId : childBmsMenuMap.keySet()) {
  12.             BmsMenuVO menuVO = childBmsMenuMap.get(bmsMenuId);
  13.             Long parentId = menuVO.getParentId();
  14.             if (parentId == null) {
  15.                 bmsMenuTree.add(menuVO);
  16.             } else {
  17.                 BmsMenuVO parentMenuVO = childBmsMenuMap.get(parentId);
  18.                 if (parentMenuVO.getChildBmsMenuList() == null) {
  19.                     parentMenuVO.setChildBmsMenuList(new ArrayList<>());
  20.                 }
  21.                 parentMenuVO.getChildBmsMenuList().add(menuVO);
  22.           }
  23. }

2、使用递归查询某个节点所在的树结构

使用场景：当我们得到一个树形结构数据时，可能需要在树形结构上对数据进行筛选，例如通过文件夹（文件）名称模糊查询相关的文件夹并展现其父级。

缺点：需要查询出完整的树形结构才能用作筛选，在数据量非常庞大的时候并不适用。

  1. @Data
  2. public class TreeDto {
  4.    private String id;
  5.    private String name;
  6.    private List<TreeDto> subsetTreeDtoList;
  10.    public TreeDto(String id,String name,List<TreeDto> subsetTreeDtoList){
  11.        this.id = id;
  12.        this.name = name;
  13.        this.subsetTreeDtoList = subsetTreeDtoList;
  14.    }
  15. }

筛选

  1.   /**
  2.     * 树形筛选查找
  3.     * @param treeDtoList 树形集合
  4.     * @param idList 筛选条件(可以是其他条件)
  5.     * @return 包含的节点数据
  6.     */
  7.    public static List<TreeDto> screenTree(List<TreeDto> treeDtoList, List<String> idList){
  8.        //最后返回的筛选完成的集合
  9.        List<TreeDto> screeningOfCompleteList = new ArrayList<>();
  10.        if (listIsNotEmpty(treeDtoList) && listIsNotEmpty(idList)){
  11.            for (TreeDto treeDto : treeDtoList){
  12.                List<TreeDto> subsetList = treeDto.getSubsetTreeDtoList();
  13.                //递归筛选完成后的返回的需要添加的数据
  14.                TreeDto addTreeDto = getSubsetPmsPlanPo(treeDto,subsetList,idList);
  15.                if (isNotEmpty(addTreeDto)){
  16.                    screeningOfCompleteList.add(addTreeDto);
  17.                }
  18.            }
  19.            return screeningOfCompleteList;
  20.        }
  21.        return null;
  22.    }
  25.    /**
  26.     * 筛选符合的集合并返回
  27.     * @param treeDto 树形类
  28.     * @param subsetTreeDtoList 子集集合
  29.     * @param idList 筛选条件
  30.     * @return 筛选成功的类
  31.     */
  32.    public static TreeDto getSubsetPmsPlanPo(TreeDto treeDto,List<TreeDto> subsetTreeDtoList,List<String> idList){
  33.        //作为筛选条件的判断值
  34.        String id = treeDto.getId();
  35.        //有子集时继续向下寻找
  36.        if (listIsNotEmpty(subsetTreeDtoList)){
  37.            List<TreeDto> addTreeDtoList = new ArrayList<>();
  38.            for (TreeDto subsetTreeDto : subsetTreeDtoList){
  39.                List<TreeDto> subsetList = subsetTreeDto.getSubsetTreeDtoList();
  40.                TreeDto newTreeDto = getSubsetPmsPlanPo(subsetTreeDto,subsetList,idList);
  41.                //当子集筛选完不为空时添加
  42.                if (isNotEmpty(newTreeDto)){
  43.                    addTreeDtoList.add(newTreeDto);
  44.                }
  45.            }
  46.            //子集满足条件筛选时集合不为空时，替换对象集合内容并返回当前对象
  47.            if (listIsNotEmpty(addTreeDtoList)){
  48.                treeDto.setSubsetTreeDtoList(addTreeDtoList);
  49.                return treeDto;
  50.                //当前对象子集对象不满足条件时，判断当前对象自己是否满足筛选条件，满足设置子集集合为空，并返回当前对象
  51.            }else if (listIsEmpty(addTreeDtoList) && idList.contains(id)){
  52.                treeDto.setSubsetTreeDtoList(null);
  53.                return treeDto;
  54.            }else {
  55.                //未满足筛选条件直接返回null
  56.                return null;
  57.            }
  58.        }else {
  59.            //无子集时判断当前对象是否满足筛选条件
  60.            if (idList.contains(id)){
  61.                return treeDto;
  62.            }else {
  63.                return null;
  64.            }
  65.        }
  66.    }
  68.    /**
  69.     * 判断集合为空
  70.     * @param list 需要判断的集合
  71.     * @return 集合为空时返回 true
  72.     */
  73.    public static boolean listIsEmpty(Collection list){
  74.        return  (null == list || list.size() == 0);
  75.    }
  77.    /**
  78.     * 判断集合非空
  79.     * @param list 需要判断的集合
  80.     * @return 集合非空时返回 true
  81.     */
  82.    public static boolean listIsNotEmpty(Collection list){
  83.        return !listIsEmpty(list);
  84.    }
  86.    /**
  87.     * 判断对象为null或空时
  88.     * @param object 对象
  89.     * @return 对象为空或null时返回 true
  90.     */
  91.    public static boolean isEmpty(Object object) {
  92.        if (object == null) {
  93.            return (true);
  94.        }
  95.        if ("".equals(object)) {
  96.            return (true);
  97.        }
  98.        if ("null".equals(object)) {
  99.            return (true);
  100.        }
  101.        return (false);
  102.    }
  104.    /**
  105.     * 判断对象非空
  106.     * @param object 对象
  107.     * @return 对象为非空时返回 true
  108.     */
  109.    public static boolean isNotEmpty(Object object) {
  110.        if (object != null && !object.equals("") && !object.equals("null")) {
  111.            return (true);
  112.        }
  113.        return (false);
  114.    }
  116.    public static void main(String[] args) {
  117.        TreeDto treeDto1 = new TreeDto("1","A",new ArrayList<TreeDto>());
  118.        TreeDto treeDto1_1 = new TreeDto("1.1","A-A",new ArrayList<TreeDto>());
  119.        TreeDto treeDto1_2 = new TreeDto("1.2","A-B",new ArrayList<TreeDto>());
  120.        TreeDto treeDto1_3 = new TreeDto("1.3","A-C",new ArrayList<TreeDto>());
  121.        treeDto1.getSubsetTreeDtoList().add(treeDto1_1);
  122.        treeDto1.getSubsetTreeDtoList().add(treeDto1_2);
  123.        treeDto1.getSubsetTreeDtoList().add(treeDto1_3);
  125.        TreeDto treeDto2 = new TreeDto("2","B",new ArrayList<TreeDto>());
  126.        TreeDto treeDto2_1 = new TreeDto("2.1","B-A",new ArrayList<TreeDto>());
  127.        TreeDto treeDto2_2 = new TreeDto("2.2","B-B",new ArrayList<TreeDto>());
  128.        TreeDto treeDto2_3 = new TreeDto("2.3","B-C",new ArrayList<TreeDto>());
  129.        TreeDto treeDto2_3_1 = new TreeDto("2.3.1","B-C-A",null);
  130.        treeDto2.getSubsetTreeDtoList().add(treeDto2_1);
  131.        treeDto2.getSubsetTreeDtoList().add(treeDto2_2);
  132.        treeDto2.getSubsetTreeDtoList().add(treeDto2_3);
  133.        treeDto2.getSubsetTreeDtoList().get(2).getSubsetTreeDtoList().add(treeDto2_3_1);
  135.        String[] array = {"1.3","2.2","2.3.1"};
  136.        List<String> idList = Arrays.asList(array);
  137.        List<TreeDto> treeDtoList = new ArrayList<>();
  138.        treeDtoList.add(treeDto1);
  139.        treeDtoList.add(treeDto2);
  140.        System.out.println(JSON.toJSONString(screenTree(treeDtoList,idList)));
  141.    }
  142. }

返回结果为
image

原文链接：https://www.cnblogs.com/cgy1995/p/17782289.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号