封装树形数据结构

此方法使用于通过id,pid关联的树形对象.多用于无深度确定的树形结构

1.创建树形结构对象

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

 */
public class Tree<T>{
   
   //节点ID，这个节点的唯一标识，通常情况下使用主键或者列的唯一标识都可以。
   //这里使用String类型是为了兼容所有的标识，可以是数字类型的字符形式
   private String id;
   
   //节点的父节点
   private String parentId;
   
   //这个节点显示的文本
   private String text;
   
   //是否有父节点
   private Boolean haveParent = false;
   
   //是否有子节点
   private Boolean haveChildrens = false;
   
   //节点子节点
   private List<Tree<T>> children = new ArrayList<Tree<T>>();
      
   //节点的额外属性，比如把展开属性和选中属性设置在这里
   private Map<String,Object> attributes;

   public String getId() {
      return id;
   }

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

   public String getParentId() {
      return parentId;
   }


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


   public String getText() {
      return text;
   }


   public void setText(String text) {
      this.text = text;
   }

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

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

   public Map<String, Object> getAttributes() {
      return attributes;
   }

   public void setAttributes(Map<String, Object> attributes) {
      this.attributes = attributes;
   }


   public Boolean getHaveParent() {
      return haveParent;
   }


   public void setHaveParent(Boolean haveParent) {
      this.haveParent = haveParent;
   }

   public Boolean getHaveChildrens() {
      return haveChildrens;
   }


   public void setHaveChildrens(Boolean haveChildrens) {
      this.haveChildrens = haveChildrens;
   }
   
}

2.工具类,将集合转为树形结构

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

import com.test.Tree;


public class TreeUtil {

   public static <T> Tree<T> buildToTree(List<Tree<T>> nodes,String rootNodeName) {

      //如果节点的List为null，就返回null
      if (nodes == null) {
         return null;
      }
      //没有父节点节点列表
      List<Tree<T>> topNodes = new ArrayList<Tree<T>>();

      
      for (Tree<T> children : nodes) {
         
         //遍历所有的节点，找出所有的顶级节点，将没有父节点的节点存起来
         String pid = children.getParentId();
         if (pid == null || "".equals(pid)) {
            topNodes.add(children);
            //只要没有父节点，添加后就跳过
            continue;
         }
   
         //那么剩下的节点都是有父节点,我们给这个孩子节点找父亲节点
         for (Tree<T> parent : nodes) {
            String id = parent.getId();
            
            if (id != null && id.equals(pid)) {
               parent.getChildren().add(children);
               children.setHaveParent(true);
               parent.setHaveChildrens(true);
               //如果找到父节点并将子节点设置到这个父节点上就可以停止继续循环查找
               break;
            }
         }

      }

      //把根节点返回，如果没有父节点不只一个，我们给这些节点创建一个根节点
      Tree<T> root = new Tree<T>();
      if (topNodes.size() == 1) {
         root = topNodes.get(0);
      } else {
         root.setId("-1");
         root.setParentId("");
         root.setHaveParent(false);
         root.setHaveChildrens(true);
         root.setAttributes(null);
         root.setChildren(topNodes);
         root.setText(rootNodeName);

      }

      return root;
   }
}