Java递归/遍历，实现遍历父子级菜单

已于 2024-05-14 19:51:25 修改
阅读量745 收藏 5
点赞数 4
分类专栏： 有关Java项目的参考文章 文章标签： 前端 数据库
于 2024-02-20 20:32:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67573348/article/details/136198164
版权

目录

准备工作

迭代实现

递归实现

未带有显示顺序的递归遍历

sid的树结构

java实现CRUD思路

service

serviceImpl

controller

mybatis plus分页思路

service

serviceImpl

controller

树结构漏洞补差2.0

准备工作

create table dormitory_management.fuzi
(
    menu_id       bigint auto_increment comment '菜单ID'
        primary key,
    menu_name     varchar(50)      not null comment '菜单名称',
    parent_id     bigint default 0 null comment '父菜单ID',
    display_order int    default 0 null comment '显示顺序'
);

-- 添加中文测试数据
INSERT INTO dormitory_management.fuzi (menu_name, parent_id, display_order) VALUES
('顶级菜单1', 0, 1),
('顶级菜单2', 0, 2),
('子菜单1-1', 1, 1),
('子菜单1-2', 1, 2),
('子菜单2-1', 2, 1);

@Data
@ToString
public class Fuzi {
    private Long menuId;
    private String menuName;
    private Long parentId;
    private Long  displayOrder;
    private List<Fuzi> children; // 子菜单列表
}

迭代实现

分析图：


//Service层
public interface FuziService extends IService<Fuzi> {
    List<Fuzi> getFuziMenuTreeWithoutChildren();

    List<Fuzi> buildMenuTree(List<Fuzi> menuList);
}

package com.lyh.mp.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lyh.mp.entity.Fuzi;
import com.lyh.mp.mapper.FuziMapper;
import com.lyh.mp.service.FuziService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * @author Mtz
 * @version 1.0
 * @2024/2/2015:49
 * @function
 * @comment
 */
@Service
public class FuziServiceImpl extends ServiceImpl<FuziMapper, Fuzi> implements FuziService {


    @Autowired
    private FuziMapper fuziMapper;


    public List<Fuzi> getFuziMenuTreeWithoutChildren() {
        QueryWrapper<Fuzi> fuzi = new QueryWrapper<>();
        fuzi.select("menu_id", "menu_name", "parent_id","display_order"); // 指定查询的字段
        List<Fuzi> menuList = fuziMapper.selectList(fuzi);
        return buildMenuTree(menuList); // 构建菜单树
    }

    // 构建父子级菜单树
    public List<Fuzi> buildMenuTree(List<Fuzi> menuList) {
        Map<Long, Fuzi> menuMap = new HashMap<>();

        // 将菜单放入Map中，以菜单ID作为键
        for (Fuzi menu : menuList) {
            menuMap.put(menu.getMenuId(), menu);
        }

        // 遍历菜单列表，将子菜单添加到对应的父菜单的children属性中
        List<Fuzi> treeMenu = new ArrayList<>();
        for (Fuzi menu : menuList) {
            Long parentId = menu.getParentId();
            if (parentId == null || parentId == 0) {
                // 顶级菜单
                treeMenu.add(menu);
            } else {
                // 子菜单
                Fuzi parentMenu = menuMap.get(parentId);
                if (parentMenu != null) {
                    if (parentMenu.getChildren() == null) {
                        parentMenu.setChildren(new ArrayList<>());
                    }
                    parentMenu.getChildren().add(menu);
                }
            }
        }

        // 对顶级菜单及其子菜单按照 display_order 排序
        sortTreeMenu(treeMenu);

        return treeMenu;
    }

    // 递归排序树形结构的菜单
    private void sortTreeMenu(List<Fuzi> treeMenu) {
        for (Fuzi menu : treeMenu) {
            if (menu.getChildren() != null && !menu.getChildren().isEmpty()) {
                // 递归排序子菜单
                sortTreeMenu(menu.getChildren());
            }
        }

        // 对当前层级的菜单按照 display_order 排序
        Collections.sort(treeMenu, Comparator.comparingLong(Fuzi::getDisplayOrder));
    }
    /*
    - Fuzi(menuId=1, menuName=顶级菜单1, parentId=0, displayOrder=1, children=[
  - Fuzi(menuId=3, menuName=子菜单1-1, parentId=1, displayOrder=1, children=null),
  - Fuzi(menuId=4, menuName=子菜单1-2, parentId=1, displayOrder=2, children=null)
  ])

- Fuzi(menuId=2, menuName=顶级菜单2, parentId=0, displayOrder=2, children=[
  - Fuzi(menuId=5, menuName=子菜单2-1, parentId=2, displayOrder=1, children=null)
  ])

     */
}

递归实现


    // 构建父子级菜单树
    public List<Fuzi> buildMenuTree(List<Fuzi> menuList) {
        Map<Long, Fuzi> menuMap = new HashMap<>();
        for (Fuzi menu : menuList) {
            menuMap.put(menu.getMenuId(), menu);
        }

        List<Fuzi> treeMenu = new ArrayList<>();
        for (Fuzi menu : menuList) {
            if (menu.getParentId() == null || menu.getParentId() == 0) {
                buildChildMenu(menu, menuMap);
                treeMenu.add(menu);
            }
        }

        return treeMenu;
    }

    private void buildChildMenu(Fuzi parentMenu, Map<Long, Fuzi> menuMap) {
        Long parentId = parentMenu.getMenuId();
        List<Fuzi> children = new ArrayList<>();

        menuMap.values().stream()
                .filter(menu -> parentId.equals(menu.getParentId()))
                .forEach(menu -> {
                    buildChildMenu(menu, menuMap);
                    children.add(menu);
                });

        children.sort(Comparator.comparingLong(Fuzi::getDisplayOrder));
        parentMenu.setChildren(children);
    }

未带有显示顺序的递归遍历

    public List<Fuzi> getFuziMenuTreeWithoutChildren() {
        QueryWrapper<Fuzi> fuzi = new QueryWrapper<>();
        fuzi.select("menu_id", "menu_name", "parent_id"); // 指定查询的字段
        List<Fuzi> menuList = fuziMapper.selectList(fuzi);
        return buildMenuTree(menuList); // 构建菜单树
    }

    // 构建父子级菜单树
     public List<Fuzi> buildMenuTree(List<Fuzi> menuList) {
        Map<Long, Fuzi> menuMap = new HashMap<>();

        // 将菜单放入Map中，以菜单ID作为键
        for (Fuzi menu : menuList) {
            menuMap.put(menu.getMenuId(), menu);
        }

         System.out.println(menuMap);


        // 遍历菜单列表，将子菜单添加到对应的父菜单的children属性中
        List<Fuzi> treeMenu = new ArrayList<>();
        for (Fuzi menu : menuList) {
            Long parentId = menu.getParentId();
            if (parentId == null || parentId == 0) {
                // 顶级菜单
                treeMenu.add(menu);
            } else {
                // 子菜单
                Fuzi parentMenu = menuMap.get(parentId);
                if (parentMenu != null) {
                    if (parentMenu.getChildren() == null) {
                        parentMenu.setChildren(new ArrayList<>());
                    }
                    parentMenu.getChildren().add(menu);
                }
            }
        }

        return treeMenu;
    }

sid的树结构

    @TableId
    private Long id;
    //分类名称
//    @NotEmpty(message = "分类名称不能为空")
    @NotEmpty(message = "分类名称不能为空")
    private String categoriesName;
    //父类id
//    @NotNull(message = "111")
    private Long categoriesPid;

    @TableField(exist = false)
    private List<ScCategories> categoriesSids;
    
    @TableField(exist = false)
    private List<ScCategories> children;

遍历实现

    public List<ScCategories> buildMenuTree(List<ScCategories> menuList) {
        Map<Long, ScCategories> menuMap = new HashMap<>();

        // 将菜单放入Map中，以菜单ID作为键
        for (ScCategories menu : menuList) {
            menuMap.put(menu.getId(), menu);
        }

        System.out.println(menuMap.values());
        // 遍历菜单列表，将子菜单添加到对应的父菜单的children属性中
        List<ScCategories> treeMenu = new ArrayList<>();
        for (ScCategories categories : menuList) {
            Long parentId = categories.getCategoriesPid();
            Long childId = categories.getCategoriesSid(); // 获取子ID
            if (parentId == null || parentId == 0) {
                // 顶级菜单
                treeMenu.add(categories);
            } else {
                // 子菜单
                ScCategories parentMenu = menuMap.get(parentId);
                if (parentMenu != null) {
                    if (parentMenu.getChildren() == null) {
                        parentMenu.setChildren(new ArrayList<>());
                    }
                    parentMenu.getChildren().add(categories);
                }
            }

            // 将当前分类添加为父分类的子分类
            if (childId != null && childId != 0) {
                ScCategories childMenu = menuMap.get(childId);
                if (childMenu != null) {
                    if (childMenu.getChildren() == null) {
                        childMenu.setChildren(new ArrayList<>());
                    }
                    childMenu.getChildren().add(categories);
                }
            }
        }

        return treeMenu;
    }

java实现CRUD思路

service

public interface ScStoreCategoriesService {


    // 店铺分页查询.
    IPage<ScStoreCategories> selectInfo(ScStoreCategories scStoreCategories, Pageable pageable);

    ResponseEntity<List<ScStoreCategories>> selectInfos(ScStoreCategories scStoreCategories);

    // 根据id 返回
    ResponseEntity<ScStoreCategories> getByIdInfo(ScStoreCategories scStoreCategories);

    // 修改店铺
    ResponseEntity<String> saveOrUpdateInfo(ScStoreCategories scStoreCategories);

    // 删除店铺
    ResponseEntity<String> removeByIdInfo(ScStoreCategories scStoreCategories);

    //添加店铺
    ResponseEntity<String> insertInfo(ScStoreCategories scStoreCategories);

    // 添加店铺的子分类
    ResponseEntity<String> insertInfos(ScStoreCategories scStoreCategories);
}

serviceImpl

package co.yixiang.shopping.service.impl;

import co.yixiang.common.service.impl.BaseServiceImpl;
import co.yixiang.shopping.entity.ScStoreCategories;
import co.yixiang.shopping.mapper.ScStoreCategoriesMapper;
import co.yixiang.shopping.service.ScStoreCategoriesService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author Mtz
 * @version 1.0
 * @2024/3/2517:50
 * @function
 * @comment
 */
@Service
public class ScStoreCategoriesServiceImpl extends BaseServiceImpl<ScStoreCategoriesMapper, ScStoreCategories> implements ScStoreCategoriesService {


    @Autowired
    private ScStoreCategoriesMapper scStoreCategoriesMapper;

    @Override
    public IPage<ScStoreCategories> selectInfo(ScStoreCategories scStoreCategories, Pageable pageable) {
        //根据店铺名分页查询
        Page<ScStoreCategories> scStoreCategoriesPage = scStoreCategoriesMapper.selectPage(new Page<>(pageable.getPageNumber(),
                pageable.getPageSize()), new LambdaQueryWrapper<ScStoreCategories>()
                .eq(ScStoreCategories::getCategoriesPid, 0)    // 查出顶级父类
                .like(!Objects.isNull(scStoreCategories.getCategoriesName()),
                        ScStoreCategories::getCategoriesName, scStoreCategories.getCategoriesName()));

        List<ScStoreCategories> storeCategories = scStoreCategoriesPage.getRecords();

        storeCategories.forEach(record -> {
            List<ScStoreCategories> storeCategories2 = scStoreCategoriesMapper.selectList(
                    new LambdaQueryWrapper<ScStoreCategories>()
                            .eq(ScStoreCategories::getCategoriesPid, record.getId()));
            record.setStr("A");
            record.setChildren(storeCategories2);
        });


        return scStoreCategoriesPage;

    }

    @Override
    public ResponseEntity<List<ScStoreCategories>> selectInfos(ScStoreCategories scStoreCategories) {
        // 名字模糊查询
        List<ScStoreCategories> storeCategories = scStoreCategoriesMapper.selectList(
                new LambdaQueryWrapper<ScStoreCategories>()
                        .like(!Objects.isNull(scStoreCategories.getCategoriesName()), ScStoreCategories::getCategoriesName, scStoreCategories.getCategoriesName()));

        List<ScStoreCategories> storeCategories1 = buildMenuTree(storeCategories);



        return ResponseEntity.ok(storeCategories1);
    }
    @Override
    public ResponseEntity<ScStoreCategories> getByIdInfo(ScStoreCategories scStoreCategories) {
        ScStoreCategories storeCategories = scStoreCategoriesMapper.selectById(scStoreCategories.getId());
        return storeCategories != null
                ? ResponseEntity.ok(storeCategories) // 如果查询结果不为 null，返回 OK 状态码和查询到的数据
                : ResponseEntity.status(HttpStatus.NOT_FOUND).body(null); // 如果查询结果为 null，返回 404 NOT FOUND 状态码
    }

    @Override
    public ResponseEntity<String> saveOrUpdateInfo(ScStoreCategories scStoreCategories) {
        return scStoreCategoriesMapper.updateById(scStoreCategories) > 0 ? ResponseEntity.ok("更新成功")
                : ResponseEntity.status(HttpStatus.BAD_REQUEST).body("更新失败");
    }

    @Override
    public ResponseEntity<String> removeByIdInfo(ScStoreCategories scStoreCategories) {
        // 查看是否还有子节点
        boolean hasChildren = hasChildren(scStoreCategories.getCategoriesPid());

        if (hasChildren == true) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("还有子结点");
        }

        return scStoreCategoriesMapper.deleteById(scStoreCategories.getId()) > 0 ? ResponseEntity.ok("删除成功") :
                ResponseEntity.status(HttpStatus.NOT_FOUND).body("删除失败");
    }

    @Override
    public ResponseEntity<String> insertInfo(ScStoreCategories scStoreCategories) {
        return scStoreCategoriesMapper.insert(scStoreCategories) > 0 ? ResponseEntity.ok("添加成功") : ResponseEntity.status(HttpStatus.NOT_FOUND).body("添加失败");
    }

    //  添加店铺子分类
    @Override
    public ResponseEntity<String> insertInfos(ScStoreCategories scStoreCategories) {

        // 子分类的 pid 设置为 父的 id  ，name -- name ,
        ScStoreCategories storeCategories = new ScStoreCategories();
        storeCategories.setCategoriesPid(scStoreCategories.getId());
        storeCategories.setCategoriesName(scStoreCategories.getCategoriesName());

        return scStoreCategoriesMapper.insert(storeCategories) > 0 ? ResponseEntity.ok("添加成功") : ResponseEntity.status(HttpStatus.NOT_FOUND).body("添加失败");
    }

    private boolean hasChildren(Long parentId) {
        Long count = scStoreCategoriesMapper.selectCount(new LambdaQueryWrapper<ScStoreCategories>()
                .eq(ScStoreCategories::getCategoriesPid, parentId));
        return count > 0;
    }


    // 构建父子级菜单树
    public List<ScStoreCategories> buildMenuTree(List<ScStoreCategories> menuList) {
        Map<Long, ScStoreCategories> menuMap = new HashMap<>();

        // 将菜单放入Map中，以菜单ID作为键
        for (ScStoreCategories menu : menuList) {
            menuMap.put(menu.getId(), menu);
        }

        // 遍历菜单列表，将子菜单添加到对应的父菜单的children属性中
        List<ScStoreCategories> treeMenu = new ArrayList<>();
        for (ScStoreCategories menu : menuList) {
            Long parentId = menu.getCategoriesPid();
            if (parentId == null || parentId == 0) {
                // 顶级菜单
                treeMenu.add(menu);
            } else {
                // 子菜单
                ScStoreCategories parentMenu = menuMap.get(parentId);
                if (parentMenu != null) {
                    if (parentMenu.getChildren() == null) {
                        parentMenu.setChildren(new ArrayList<>());
                    }
                    parentMenu.getChildren().add(menu);
                }
            }
        }
        return treeMenu;
    }


}

controller

package co.yixiang.shopping.controller;

import co.yixiang.shopping.entity.ScStoreCategories;
import co.yixiang.shopping.service.ScStoreCategoriesService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author Mtz
 * @version 1.0
 * @2024/3/2518:37
 * @function
 * @comment
 */
@RestController
@RequestMapping("/storecategories")
public class ScStoreCategoriesController {
    @Autowired
    private ScStoreCategoriesService scStoreCategoriesService;

    // 店铺分页查询.
    @GetMapping("/list")
    public ResponseEntity<IPage<ScStoreCategories>> selectInfo(ScStoreCategories scStoreCategories, Pageable pageable) {
        return ResponseEntity.ok(scStoreCategoriesService.selectInfo(scStoreCategories, pageable));
    }


    @GetMapping("/selectInfos")
    public ResponseEntity<List<ScStoreCategories>> selectInfos(ScStoreCategories scStoreCategories) {
        return scStoreCategoriesService.selectInfos(scStoreCategories);
    }


    // 根据id查询店铺
    @GetMapping("/getbyid")
    public ResponseEntity<ScStoreCategories> getByIdInfo(ScStoreCategories scStoreCategories) {
        return scStoreCategoriesService.getByIdInfo(scStoreCategories);
    }

    // 修改店铺信息
    @PostMapping("/saveOrUpdateInfo")
    public ResponseEntity<String> saveOrUpdateInfo(@RequestBody ScStoreCategories scStoreCategories) {
        return scStoreCategoriesService.saveOrUpdateInfo(scStoreCategories);
    }

    // 删除店铺
    @PostMapping("/removeByIdInfo")
    public ResponseEntity<String> removeByIdInfo(@RequestBody ScStoreCategories scStoreCategories) {
        return scStoreCategoriesService.removeByIdInfo(scStoreCategories);
    }

    // 添加店铺
    @PostMapping("/insertInfo")
    public ResponseEntity<String> insertInfo(@RequestBody ScStoreCategories scStoreCategories) {
        return scStoreCategoriesService.insertInfo(scStoreCategories);
    }

    // 添加子店铺
    @PostMapping("/insertInfos")
    public ResponseEntity<String> insertInfos(@RequestBody ScStoreCategories scStoreCategories) {
        return scStoreCategoriesService.insertInfos(scStoreCategories);
    }
}

mybatis plus分页思路

service

    /**
     * 分页查询物流信息
     */
    IPage<ScStoreCategories> selectInfoa(ScStoreCategories scStoreCategories, Pageable pageable);

serviceImpl

    @Override
    public IPage<ScStoreCategories> selectInfoa(ScStoreCategories scStoreCategories, Pageable pageable) {
        //查询全部的数据
        List<ScStoreCategories> storeCategoriesA = scStoreCategoriesMapper.selectList(null);


        Page<ScStoreCategories> scStoreCategoriesPage = scStoreCategoriesMapper.selectPage(
                new Page<>(pageable.getPageNumber(), pageable.getPageSize()),
                new LambdaQueryWrapper<ScStoreCategories>()
                        .eq(ScStoreCategories::getCategoriesPid,0)
                        .like(!Objects.isNull(scStoreCategories.getCategoriesName()), ScStoreCategories::getCategoriesName, scStoreCategories.getCategoriesName())
        );
           //查询的顶级集合
        List<ScStoreCategories> storeCategoriesList = scStoreCategoriesPage.getRecords();

        // 构建树结构
        List<ScStoreCategories> storeCategoriesB = buildMenuTree(storeCategoriesA);


// 从 storeCategoriesList 集合中提取名称
        List<String> categoryNames = storeCategoriesList.stream()
                .map(ScStoreCategories::getCategoriesName) // 获取名称
                .collect(Collectors.toList());

// 使用名称数据来筛选 storeCategoriesB 集合中的元素
        List<ScStoreCategories> filteredCategoriesB = storeCategoriesB.stream()
                .filter(category -> categoryNames.contains(category.getCategoriesName()))
                .collect(Collectors.toList());

        scStoreCategoriesPage.setRecords(filteredCategoriesB);
        return scStoreCategoriesPage;
    }

controller

    @GetMapping("/selectInfoa")
    public   IPage<ScStoreCategories> selectInfoa(ScStoreCategories scStoreCategories, Pageable pageable) {
        return scStoreCategoriesService.selectInfoa(scStoreCategories, pageable);
    }

树结构漏洞补差2.0

    public List<ExQuestion> buildMenuTree(List<ExQuestion> menuList) {
        Map<Integer, ExQuestion> menuMap = new HashMap<>();

        // 将菜单放入Map中，以菜单ID作为键
        for (ExQuestion menu : menuList) {
            menuMap.put(menu.getId(), menu);
        }

        // 遍历菜单列表，将子菜单添加到对应的父菜单的children属性中
        List<ExQuestion> treeMenu = new ArrayList<>();
        for (ExQuestion menu : menuList) {
            Integer parentId = menu.getPid();
            ExQuestion parentMenu = menuMap.get(parentId);
            if (parentMenu == null) {
                // 如果父菜单不存在，则尝试通过pid查找
                parentMenu = menuMap.get(menu.getPid());
            }
            if (parentMenu == null) {
                // 如果仍然找不到父菜单，则将当前菜单视为顶级菜单
                treeMenu.add(menu);
            } else {
                // 找到父菜单，将当前菜单添加到父菜单的children属性中
                if (parentMenu.getChildren() == null) {
                    parentMenu.setChildren(new ArrayList<>());
                }
                parentMenu.getChildren().add(menu);
            }
        }

       // 对顶级菜单 及其子菜单按照 display_order 排序
        sortTreeMenu(treeMenu);

        return treeMenu;
    }

春来我不先开口，哪个虫儿敢作声?
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法 查找子节点_Java中使用递归算法实现查找树形结构中所有父级和子级节点...
weixin_29963537的博客
01-29 1606
场景在企业架构管理中使用树形结构进行管理，如图：注：如果A的id是B的pid，那么A就是B的父级。数据库数据如下：现在需要根据传递的id查询此节点所有的父级节点以及此节点所有的子级节点。实现递归查询父级节点1.一个节点只能有一个父级节点。2.首先根据参数传递的id属性查询到pid为这个id的对象a，然后再获取这个刚查询的对象a的id,再查询pid为对象a的id的对象b，以此类推。List resu...
递归遍历出所有父子级的层级关系【包含跨级】
qq_31217363的博客
07-02 3442
问题 需要递归遍历出所有父子级的层级关系【包含跨级】 如图：需要找出各个有父子级关联之间的层级关系，例如 节点0 和 节点1，节点0 和 节点3，节点 1 和 节点5 之间的关系（节点2 和 节点4不算） 解题思路： 1：拿到本节点的子节点 2：把子节点当主节点，获取主节点与父节点的层级关系 3：判断主节点的父节点是否为顶层节点，如果不是，则获取到父节点并递归取父节点的父节点，获取主节点与【父节点的父节点】的层级关系 4：依次判断，递归 具体案例代码： import lombok.Data; impo
Java 实现 8 大排序算法、笛卡尔积、父子级递归
蚩尤后裔-汪茂雄
07-25 1414
目录 冒泡排序 选择排序 冒泡排序 1、特点：效率低，实现简单 2、思想：每一趟将待排序序列中最大元素移到最后（反之也可以移动到最前），剩下的为新的待排序序列，重复上述步骤直到排完所有元素。 import java.util.Arrays; /** * Created by Administrator on 2018/7/19 0019. */ public class Tes...
Java通用三级菜单工具类
最新发布
Bunny的博客
05-23 345
通常在写三级菜单时会使用递归方式去写，但是时间长了会发现很多重复的代码一直在写，改，也就改几个名字。
java 递归方式构建菜单数据
正在缓冲的博客
04-15 258
实现代码： package com.neu.smz.util; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; public class TestMe...
最全Java菜单树递归_java递归生成树形菜单，今日头条java后端面试
2401_84007015的博客
05-13 955
@param menus 所有菜单。* 根据角色id获取对象集合信息。* 递归获取下级菜单。
java实现递归文件列表的方法
09-03
主要介绍了java实现递归文件列表的方法,实例分析了java采用递归算法遍历文件的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
使用java写一个父子联查的三级递归方法
weixin_35754676的博客
02-13 618
如果你想在 Java 中写一个三级递归方法来实现父子关系的联查，那么你需要定义一个数据结构来表示这种父子关系，例如，你可以使用树形结构或者图形结构。 具体来说，你可以定义一个类来表示每个结点，并使用一个List来存储该结点的子节点。然后你可以使用递归方法来遍历整棵树，在每次递归调用时遍历当前结点的子节点列表，直到没有更多的子节点为止。 下面是一个简单的例子： classNode { int...
java遍历菜单树形菜单(父子级菜单)
weixin_47084532的博客
04-14 3802
一般做这种父子级的遍历都用递归,可是对于新手来说不会用递归,不好理解,下面用纯for循环来解决一下,很简单的! 1.实体类 public class MenuCls { private Integer mId; private Integer pId; private String mName; private String path; private Boolean open=true; private Boolean checked=false;
java 树状数据，递归 从子节点找父节点
朝立的博客
01-06 7206
递归，树状数据，java
Java实现多级菜单（递归）
XieStrong
03-26 6177
Java实现多级菜单 菜单管理数据库设计 CREATE TABLE `pms_category` ( `cat_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '分类id', `name` char(50) DEFAULT NULL COMMENT '分类名称', `parent_cid` bigint(20) DEFAULT NULL COMMENT '父分类id', `cat_level` int(11) DEFAULT NULL COMME
java实现递归菜单树
09-07
本篇文章将详细讲解如何利用Java实现递归菜单树，并给出具体的代码实例。 首先，我们需要一个数据模型来表示菜单。这里使用了一个名为`Menu`的实体类，它包含了菜单的基本属性，如菜单名称、顺序、路径、父级ID以及...
C#父子关系树递归遍历方法（含源码）.rar
10-31
综上所述，这个压缩包提供的资料将教你在C#中如何实现父子关系树的递归遍历。通过学习和应用这些知识，开发者能够处理层级数据，构建和显示树形结构，并与数据库进行交互，从而在实际项目中实现类似的功能，例如展示...
php通过前序遍历树实现无需递归的无限极分类
10-23
本文将深入探讨如何使用PHP和前序遍历树（Preorder Traversal Tree）算法实现无需递归的无限级分类，以及在CodeIgniter（CI）框架下的应用。 首先，无限级分类的核心在于能够有效地存储和检索具有层级关系的数据。...
java实现多层嵌套循环参数转换
06-20
在Java编程中，多层嵌套循环...综上所述，Java实现多层嵌套循环、参数转换以及父子级结构的操作是软件开发中常见的任务，尤其在数据处理和数据库交互中。理解并熟练掌握这些技能，对于提高编程效率和代码质量至关重要。
java根据父id遍历出父子树形关系（通用）
热门推荐
qq_41844287的博客
06-27 1万+
1.创建一个实体类，此类是将需要遍历父子关系的实体类的id和父id存进该类，最终使用工具类进行统一遍历，使该工具类达到通用（多数通用工具类会损失执行效率）的目的，也可以参考我的遍历条件写出专属的更高效的方法， import lombok.Data; //此注解为自动添加get、set、toString方法的，需要jar包，可自己生成getset， @Data public class Paren...
Java递归实现菜单树
DevNinja的博客
09-26 771
上述示例创建了一个菜单树，其中包含根菜单项"Root"，以及一级菜单项"Menu 1"和"Menu 2"。“Menu 1"下有二级菜单项"Submenu 1-1"和"Submenu 1-2”，“Menu 2"下有二级菜单项"Submenu 2-1"和"Submenu 2-2”。“Submenu 1-1"下有三级菜单项"Subsubmenu 1-1-1"和"Subsubmenu 1-1-2”，“Submenu 1-2"下有三级菜单项"Subsubmenu 1-2-1”。的类，用于表示菜单树。
java 对菜单父子关系 进行遍历
CHL123456789的专栏
11-28 1437
话不多说 ，直接上代码，其中代码有参考网上其他 码友 的，具体那个帖子记不清了 ，把代码写在这 做一个记录 package cn.togeek.entity.tree; import cn.togeek.entity.Permission; import io.micrometer.core.instrument.util.StringUtils; import java.util.Arr...
Java菜单树递归
java李阳勇的博客
11-08 5863
Java菜单树递归
java 遍历文件形成父子级
07-28
你可以使用递归来遍历文件系统中的所有文件和文件夹，形成父子级关系。以下是一个示例代码： ```java import java.io.File; public class FileHierarchy { public static void main(String[] args) { String rootPath = "C:\\your\\root\\path"; // 根目录路径 File rootDir = new File(rootPath); if (!rootDir.exists()) { System.out.println("目录不存在"); return; } printFileHierarchy(rootDir, 0); } private static void printFileHierarchy(File dir, int level) { if (dir.isDirectory()) { // 打印当前目录的名称 System.out.println(getIndent(level) + dir.getName()); File[] files = dir.listFiles(); if (files != null) { for (File file : files) { printFileHierarchy(file, level + 1); // 递归调用，增加缩进级别 } } } else { // 打印文件的名称 System.out.println(getIndent(level) + dir.getName()); } } private static String getIndent(int level) { StringBuilder indent = new StringBuilder(); for (int i = 0; i < level; i++) { indent.append("\t"); // 使用制表符作为缩进 } return indent.toString(); } } ``` 你只需要将 `C:\\your\\root\\path` 替换为你要遍历的根目录路径，然后运行代码即可。它会递归地打印出所有文件和文件夹，并按照父子级关系进行缩进展示。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值