树形菜单生成 - ITeye问答

0 0

树形菜单生成5

id name pid isSon
主键菜单名称父id 是否有子菜单

<li isexpand="false">
 节点3
 <ul>
 <li>节点3.1</li>
 <li>节点3.2</li>
 </ul>
 </li>
 读取的数据就是要拼接成这样的格式，每对<li></li>就是一个节点，节点名称用包裹
 如果这个菜单下有子菜单的话，子菜单就包裹在<ul></ul>里，以此类推。我的想法就是一次性把所有的菜单拉取出来，
 在内存里采用递归遍历，发现这个菜单有子菜单就立即去查询其子菜单，只到拼接完所有的菜单。我自己拼接了很多次，由于经验不足
 没能正确的拼接出来。希望大家想想怎样拼接……

Java 递归树形菜单

2013年6月06日 10:27

xiangximingong
2
0 0 9

6个答案按时间排序按投票排序

0 0

采纳的答案

package tree;

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

import org.apache.commons.collections.CollectionUtils;

public class TreeBuilder {

 /**
 * 将集合建立成树结构
 *
 * @param dirs
 * @return
 */
 @SuppressWarnings("unchecked")
 private List<Node> buildListToTree(List<Node> dirs) {
 List<Node> roots = findRoots(dirs);
 List<Node> notRoots = (List<Node>) CollectionUtils.subtract(dirs, roots);
 for (Node root : roots) {
 root.setChildren(findChildren(root, notRoots));
 }
 return roots;
 }

 /**
 * 找出集合中的根元素
 *
 * @param allDirs
 * @return
 */
 public List<Node> findRoots(List<Node> allNodes) {
 List<Node> results = new ArrayList<Node>();
 for (Node node : allNodes) {
 boolean isRoot = true;
 for (Node comparedOne : allNodes) {
 if (node.getParentId() == comparedOne.getId()) {
 isRoot = false;
 break;
 }
 }
 if (isRoot) {
 node.setLevel(0);
 results.add(node);
 node.setRootId(node.getId());
 }
 }
 return results;
 }

 /**
 * 递归找子目录
 *
 * @param root
 * @param allDirs
 * @return
 */
 @SuppressWarnings("unchecked")
 private List<Node> findChildren(Node root, List<Node> allNodes) {
 List<Node> children = new ArrayList<Node>();

 for (Node comparedOne : allNodes) {
 if (comparedOne.getParentId() == root.getId()) {
 comparedOne.setParent(root);
 comparedOne.setLevel(root.getLevel() + 1);
 children.add(comparedOne);
 }
 }
 List<Node> notChildren = (List<Node>) CollectionUtils.subtract(allNodes, children);
 for (Node child : children) {
 List<Node> tmpChildren = findChildren(child, notChildren);
 if (tmpChildren == null || tmpChildren.size() < 1) {
 child.setLeaf(true);
 } else {
 child.setLeaf(false);
 }
 child.setChildren(tmpChildren);
 }
 return children;
 }

 public static void main(String[] args) {
 TreeBuilder tb = new TreeBuilder();
 List<Node> allNodes = new ArrayList<Node>();
 allNodes.add(new Node(1,0,"节点1"));
 allNodes.add(new Node(2,0,"节点2"));
 allNodes.add(new Node(3,0,"节点3"));
 allNodes.add(new Node(4,1,"节点4"));
 allNodes.add(new Node(5,1,"节点5"));
 allNodes.add(new Node(6,1,"节点6"));
 allNodes.add(new Node(7,4,"节点7"));
 allNodes.add(new Node(8,4,"节点8"));
 allNodes.add(new Node(9,5,"节点9"));
 allNodes.add(new Node(10,100,"节点10"));
 List<Node> roots = tb.buildListToTree(allNodes);
 for(Node n:roots){
 System.out.println(n);
 }

 }
}

package tree;

import java.util.List;

public class Node implements java.io.Serializable {
private static final long serialVersionUID = -2721191232926604726L;

private int id;

private int parentId;

private Node parent;

private List<Node> children;

private String name;

private int level;

private int sort;

private int rootId;

private String type;

private boolean isLeaf;

private String description;

public Node() {
super();
}

public Node(int id, int parentId, String name) {
super();
this.id = id;
this.parentId = parentId;
this.name = name;
}

public String getDescription() {
return description;
}

public void setDescription(String description) {
this.description = description;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public Node getParent() {
return parent;
}

public void setParent(Node parent) {
this.parent = parent;
}

public int getParentId() {
return parentId;
}

public void setParentId(int parentId) {
this.parentId = parentId;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getLevel() {
return level;
}

public void setLevel(int level) {
this.level = level;
}

public String getType() {
return type;
}

public List<Node> getChildren() {
return children;
}

public void setChildren(List<Node> children) {
this.children = children;
}

public void setType(String type) {
this.type = type;
}

public boolean isLeaf() {
return isLeaf;
}

public void setLeaf(boolean isLeaf) {
this.isLeaf = isLeaf;
}

public int getSort() {
return sort;
}

public void setSort(int sort) {
this.sort = sort;
}

public int getRootId() {
 return rootId;
 }

public void setRootId(int rootId) {
 this.rootId = rootId;
 }



 @Override
 public int hashCode() {
 final int prime = 31;
 int result = 1;
 result = prime * result + id;
 result = prime * result + parentId;
 return result;
 }

 @Override
 public boolean equals(Object obj) {
 if (this == obj)
 return true;
 if (obj == null)
 return false;
 if (getClass() != obj.getClass())
 return false;
 Node other = (Node) obj;
 if (id != other.id)
 return false;
 if (parentId != other.parentId)
 return false;
 return true;
 }

 @Override
public String toString() {
return "Node {id=" + id + ", parentId=" + parentId
+ ", children=" + children + ", name=" + name + "}";
}
}

2013年6月06日 12:05

hot002
85
0 0 7

1条评论

0 0

问题的关键，是数据结构的问题。

2013年6月07日 16:44

freezingsky
159
1 1 16

添加评论

0 0

2013年6月06日 21:04

hngmduyi
38
0 1 4

添加评论

0 0

可以用json格式返回来，
[{
    contactorName = 风扬,
    originProvinceCode = 402881e83a0586b6013a05b173960004,
    sonList=[{a="1",b="2",
           sonList_2=[{a="3",b="4",


           }]
    }],
    contactorName = 风扬_2,
     sonList=[{a="1",b="2",
           sonList_2=[{
                 a="3",
                 b="4",
                 sonList_3=[{
                    a="3",b="4"
                }]

           }]
    }],
}]

通过他们直接相关联的code把数据拼接成上面这样，然后再前台遍历就ok啦。