java实现多级菜单(递归)

菜单实体类:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Menu {
   // 菜单id
   private String id;
   // 菜单名称
   private String name;
   // 父菜单id
   private String parentId;
   // 菜单url
   private String url;
   // 菜单图标
   private String icon;
   // 菜单顺序
   private int order;
   // 子菜单
   private List<Menu> children;
   // ... 省去getter和setter方法以及toString方法
}

菜单一般需要排序,我们根据Menu的order字段进行排序:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
   * 排序,根据order排序
   */
  public Comparator<Menu> order(){
    Comparator<Menu> comparator = new Comparator<Menu>() {
      @Override
      public int compare(Menu o1, Menu o2) {
        if (o1.getOrder() != o2.getOrder()){
          return o1.getOrder() - o2.getOrder();
        }
        return 0 ;
      }
    };
    return comparator;
  }

生成树的方法:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public Map<String,Object> findTree(){
   Map<String,Object> data = new HashMap<String,Object>();
     try { //查询所有菜单
       List<Menu> allMenu = menuDao.findTree();
       //根节点
       List<Menu> rootMenu = new ArrayList<Menu>();
       for (Menu nav : allMenu) {
         if (nav.getParentId().equals( "0" )){ //父节点是0的,为根节点。
           rootMenu.add(nav);
         }
       }
       /* 根据Menu类的order排序 */
       Collections.sort(rootMenu, order());
       //为根菜单设置子菜单,getClild是递归调用的
       for (Menu nav : rootMenu) {
         /* 获取根节点下的所有子节点 使用getChild方法*/
         List<Menu> childList = getChild(nav.getId(), allMenu);
         nav.setChildren(childList);//给根节点设置子节点
       }
       /**
        * 输出构建好的菜单数据。
        *
        */
       data.put( "success" , "true" );
       data.put( "list" , rootMenu);
       return data;
     } catch (Exception e) {
       data.put( "success" , "false" );
       data.put( "list" , new ArrayList());
       return data;
     }
   }

获取子菜单:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
    * 获取子节点
    * @param id 父节点id
    * @param allMenu 所有菜单列表
    * @return 每个根节点下,所有子菜单列表
    */
   public List<Menu> getChild(String id,List<Menu> allMenu){
     //子菜单
     List<Menu> childList = new ArrayList<Menu>();
     for (Menu nav : allMenu) {
       // 遍历所有节点,将所有菜单的父id与传过来的根节点的id比较
       //相等说明:为该根节点的子节点。
       if (nav.ParentId().equals(id)){
         childList.add(nav);
       }
     }
     //递归
     for (Menu nav : childList) {
       nav.setChildren(getChild(nav.getId(), allMenu));
     }
     Collections.sort(childList,order()); //排序
     //如果节点下没有子节点,返回一个空List(递归退出)
     if (childList.size() == 0 ){
       return new ArrayList<Menu>();
     }
     return childList;
   }

最后返回的JSON串如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
{
  "success" : "true" ,
  "list" : [
    {
     "id" : "1" ,
     "name" : "Java" ,
     "parentid" : "0" ,
     "url" : "http://www.aliouchen.com" ,
     "order" : 1 ,
     "children" : [
      {
        "id" : "2" ,
        "name" : "并发编程" ,
        "parentid" : "1" ,
        "url" : "http://www.aliouchen.com" ,
        "order" : 1 ,
        "children" : []
      },
      {
        "id" : "3" ,
        "name" : "多线程" ,
        "parentid" : "1" ,
        "url" : "http://www.aliouchen.com" ,
        "order" : 2 ,
        "children" : [
          "id" : "4" ,
          "name" : "Thread" ,
          "parentid" : "3" ,
          "url" : "http://www.aliouchen.com" ,
          "order" : 1 ,
           "children" :[]
        ]
      }
     ]
    },
    {
     "id" : "5" ,
     "name" : "Python" ,
     "parentid" : "0" ,
     "url" : "http://www.aliouchen.com" ,
     "order" : 2 ,
     "children" : []
    }
   ]
}
  • 31
    点赞
  • 169
    收藏
    觉得还不错? 一键收藏
  • 21
    评论
### 回答1: Java递归可以用于动态多级菜单的创建和展示。具体步骤如下: 1. 定义菜单项类,包含名称、子菜单等属性。 2. 定义一个递归方法,用于遍历当前菜单项的子菜单,并生成HTML代码来显示菜单。 3. 在递归方法中,如果当前菜单项有子菜单,则递归调用该方法,直到没有子菜单为止。 4. 在HTML中嵌入递归方法生成的代码,即可显示动态多级菜单。 示例代码如下: ```java public class MenuItem { private String name; private List<MenuItem> subMenu; // getter and setter methods } public class Menu { private List<MenuItem> menuItems; // getter and setter methods //递归方法,生成HTML代码 public String generateHTML() { StringBuilder sb = new StringBuilder(); sb.append("<ul>"); for (MenuItem item : menuItems) { sb.append("<li>"); sb.append(item.getName()); if (item.getSubMenu() != null && item.getSubMenu().size() > 0) { sb.append(item.getSubMenu().generateHTML()); } sb.append("</li>"); } sb.append("</ul>"); return sb.toString(); } } ``` 调用方式: ```java Menu menu = new Menu(); // 添加菜单项及子菜单 String html = menu.generateHTML(); // 将html嵌入到页面中显示 ``` 以上是简单的实现,具体实现方式会因为实际需求的不同而有所差异。 ### 回答2: 在Java中,我们可以使用递归实现动态多级菜单。 首先,我们可以创建一个Menu类,其中包含菜单的名称和一个子菜单列表。然后,我们可以定义一个方法来打印菜单。在该方法中,我们可以使用递归来遍历菜单,并打印每个菜单项以及其子菜单。 为了实现递归,我们可以使用一个帮助方法来打印菜单项及其子菜单。此方法会接收一个Menu对象作为参数,并打印菜单的名称,然后遍历该菜单的子菜单列表。如果子菜单列表不为空,我们就可以使用递归来调用此方法,以打印子菜单及其子菜单的子菜单。 下面是一个示例代码: ```java class Menu { private String name; private List<Menu> subMenus; public Menu(String name) { this.name = name; this.subMenus = new ArrayList<>(); } public void addSubMenu(Menu menu) { this.subMenus.add(menu); } public void printMenu() { printMenu(this); } private void printMenu(Menu menu) { System.out.println(menu.name); for (Menu subMenu : menu.subMenus) { printMenu(subMenu); } } } public class Main { public static void main(String[] args) { Menu menu1 = new Menu("菜单1"); Menu menu2 = new Menu("菜单2"); Menu menu3 = new Menu("菜单3"); Menu subMenu1 = new Menu("子菜单1"); Menu subMenu2 = new Menu("子菜单2"); menu1.addSubMenu(subMenu1); menu1.addSubMenu(subMenu2); menu1.addSubMenu(menu2); menu2.addSubMenu(menu3); menu1.printMenu(); } } ``` 此示例代码中,我们创建了一个包含多级菜单菜单结构,并使用printMenu方法打印了所有菜单项。运行此代码,将会输出以下内容: ``` 菜单1 子菜单1 子菜单2 菜单2 菜单3 ``` 通过使用递归,我们可以灵活地实现动态多级菜单。无论菜单层级有多深,都可以使用相同的方法来打印菜单。 ### 回答3: 在Java实现递归动态多级菜单的方法如下: 首先,创建一个菜单项类Menu,该类包含菜单项的名称和子菜单列表。菜单项的子菜单列表也是Menu对象的集合。 在Menu类中,我们定义一个递归方法printMenu,用于打印菜单项及其子菜单。在printMenu方法中,我们首先打印当前菜单项的名称,然后遍历子菜单列表,递归调用printMenu方法打印子菜单项。 接下来,在主函数中,我们创建多级菜单结构。可以通过手动创建菜单项的方式,也可以通过解析外部数据文件(如JSON或XML)的方式动态创建菜单项。 最后,我们调用菜单根节点的printMenu方法,即可打印出菜单的整个层级结构。 下面是一个简单的示例代码: ```java class Menu { private String name; private List<Menu> subMenus; public Menu(String name) { this.name = name; this.subMenus = new ArrayList<>(); } public void addSubMenu(Menu subMenu) { subMenus.add(subMenu); } public void printMenu() { System.out.println(name); for (Menu subMenu : subMenus) { subMenu.printMenu(); } } } public class Main { public static void main(String[] args) { Menu rootMenu = new Menu("菜单"); Menu menu1 = new Menu("菜单1"); Menu menu2 = new Menu("菜单2"); Menu menu3 = new Menu("菜单3"); rootMenu.addSubMenu(menu1); rootMenu.addSubMenu(menu2); rootMenu.addSubMenu(menu3); Menu menu11 = new Menu("菜单1-1"); Menu menu12 = new Menu("菜单1-2"); menu1.addSubMenu(menu11); menu1.addSubMenu(menu12); menu2.addSubMenu(new Menu("菜单2-1")); rootMenu.printMenu(); } } ``` 以上代码将会输出如下结果: 菜单 菜单1 菜单1-1 菜单1-2 菜单2 菜单2-1 菜单3 这样,我们就实现递归动态多级菜单的功能。无论菜单结构有多复杂,只需要递归调用printMenu方法,就能打印出整个菜单的层级结构。
评论 21
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值