递归、嵌套for循环、map集合方式实现树形结构菜单列表查询

有时候， 我们需要用到菜单列表，但是怎么样去实现一个菜单列表的编写呢，这是一重要的问题。

比如我们需要编写一个树形结构的菜单，那么我们可以使用JQuery的zTree插件：http://www.treejs.cn/v3/main.php#_zTreeInfo

例如现在需要编写一个这样的菜单列表。那么就可以使用JQuery的zTree插件。

先看一下数据库表结构。

CREATE TABLE `permission` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `pid` int(11) DEFAULT NULL,
  `url` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

1、前端页面。

                <div class="panel-body">

                    <ul id="permissionTree" class="ztree"></ul>

                </div>

<script>
   $(function () {

       var setting = {
           async: {
               enable: true,
               url:"${APP_PATH}/permission/loadData",
               autoParam:["id", "name=n", "level=lv"],
               otherParam:{"otherParam":"zTreeAsyncTest"},
           }


       };

        //树形结构
       $.fn.zTree.init($("#permissionTree"), setting);
    });
</script>

2、在这里呢，我使用的是ssm框架。所以就提交到controller层来进行操作。

Permission类的代码

import java.util.ArrayList;
import java.util.List;

public class Permission {

    private Integer id;
    private String name;
    private String url;
    private Integer pid;
    private boolean open = true;
    private boolean checked = false;
    private String icon;
    private List<Permission> children = new ArrayList<Permission>();
    
    public boolean isChecked() {
        return checked;
    }
    public void setChecked(boolean checked) {
        this.checked = checked;
    }
    public String getIcon() {
        return icon;
    }
    public void setIcon(String icon) {
        this.icon = icon;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public Integer getPid() {
        return pid;
    }
    public void setPid(Integer pid) {
        this.pid = pid;
    }
    public boolean isOpen() {
        return open;
    }
    public void setOpen(boolean open) {
        this.open = open;
    }
    public List<Permission> getChildren() {
        return children;
    }
    public void setChildren(List<Permission> children) {
        this.children = children;
    }
    
}

 使用controller这里我使用三种方式来进行查找 。

　　（1）递归方式读取各节点

controller层

    /**
     * 异步加载树结点
     * @return
     */
    @RequestMapping("/loadData")
    @ResponseBody
    public List<Permission> loadData(){
        // 递归查询数据
    Permission parent = new Permission();
    parent.setId(0);
    queryChildPermissions(parent);
    return parent.getChildren();        
    }
    /**
     * 递归查询许可信息
     * 1） 方法自己调用自己
     * 2）方法一定要存在跳出逻辑
     * 3）方法调用时，参数之间应该有规律
     * 4） 递归算法，效率比较低
     * @param parent
     */
    private  void queryChildPermissions(Permission parent){
        List<Permission> childPermissions = permissionService.queryChildPermissions(parent.getId());
        for (Permission permission :childPermissions) {
            queryChildPermissions(permission);
        }
        parent.setChildren(childPermissions);
    }

　service层

    public Permission queryRootPermission() {
        return permissionMapper.queryRootPermission();
    }

 mappern层

    @Select("select * from permission where pid is null")
    Permission queryRootPermission();

　　（2）嵌套for循环方式读取各节点

controller层

    /**
     * 异步加载树结点
     * @return
     */
    @RequestMapping("/loadData")
    @ResponseBody
    public List<Permission> loadData(){
        List<Permission> permissions=new ArrayList<Permission>();
        // 查询所有的许可数据
        List<Permission> ps = permissionService.queryAll();
        for ( Permission p : ps ) {
            // 子节点
            Permission child = p;
            if ( p.getPid() == 0 ) {
                permissions.add(p);
            } else {
                for ( Permission innerPermission : ps ) {
                    if ( child.getPid().equals(innerPermission.getId()) ) {
                        // 父节点
                        Permission parent = innerPermission;
                        // 组合父子节点的关系
                        parent.getChildren().add(child);
                        break;
                    }
                }
            }
        }


       return permissions;
    }

 service层

    public List<Permission> queryAll() {
        return permissionMapper.queryAll();
    }

mapper层

    @Select("select * from permission")
    List<Permission> queryAll();

 　　（3）map集合方式读取各节点

 controller层

    /**
     * 异步加载树结点
     * @return
     */
    @RequestMapping("/loadData")
    @ResponseBody
    public List<Permission> loadData(){
        List<Permission> permissions=new ArrayList<Permission>();

        // 查询所有的许可数据
        List<Permission> ps = permissionService.queryAll();

        Map<Integer, Permission> permissionMap = new HashMap<Integer, Permission>();
        for (Permission p : ps) {
            permissionMap.put(p.getId(), p);
        }
        for ( Permission p : ps ) {
            Permission child = p;
            if ( child.getPid() == 0 ) {
                permissions.add(p);
            } else {
                Permission parent = permissionMap.get(child.getPid());
                parent.getChildren().add(child);
            }
        }
       return permissions;
    }

service层

    public List<Permission> queryAll() {
        return permissionMapper.queryAll();
    }

mapper层

    @Select("select * from permission")
    List<Permission> queryAll();

三种方法的总结 ：

使用递归会使数据库查询非常频繁，不能进行性能优化

使用嵌套for循环没有使用索引，不够快速

使用map集合就使用了索引，加快查询速度。