java之TreeUtils生成一切物件樹形結構案例

 /**
   * 樹節點父類別，所有需要使用{@linkplain TreeUtils}工具類形成樹形結構等操作的節點都需要實現該介面
   *
   * @param <T> 節點id型別
   */
  public interface TreeNode<T> {
    /**
     * 獲取節點id
     *
     * @return 樹節點id
     */
    T id();
    /**
     * 獲取該節點的父節點id
     *
     * @return 父節點id
     */
    T parentId();
    /**
     * 是否是根節點
     *
     * @return true：根節點
     */
    boolean root();
    /**
     * 設定節點的子節點列表
     *
     * @param children 子節點
     */
    void setChildren(List<? extends TreeNode<T>> children);
    /**
     * 獲取所有子節點
     *
     * @return 子節點列表
     */
    List<? extends TreeNode<T>> getChildren();
  }

/**
 * 樹形結構工具類
 *
 * @author meilin.huang
 * @version 1.0
 * @date 2019-08-24 1:57 下午
 */
public class TreeUtils {
  /**
   * 根據所有樹節點列表，生成含有所有樹形結構的列表
   *
   * @param nodes 樹形節點列表
   * @param <T>  節點型別
   * @return 樹形結構列表
   */
  public static <T extends TreeNode<?>> List<T> generateTrees(List<T> nodes) {
    List<T> roots = new ArrayList<>();
    for (Iterator<T> ite = nodes.iterator(); ite.hasNext(); ) {
      T node = ite.next();
      if (node.root()) {
        roots.add(node);
        // 從所有節點列表中刪除該節點，以免後續重複遍歷該節點
        ite.remove();
      }
    }
    roots.forEach(r -> {
      setChildren(r, nodes);
    });
    return roots;
  }
  /**
   * 從所有節點列表中查詢並設定parent的所有子節點
   *
   * @param parent 父節點
   * @param nodes 所有樹節點列表
   */
  @SuppressWarnings("all")
  public static <T extends TreeNode> void setChildren(T parent, List<T> nodes) {
    List<T> children = new ArrayList<>();
    Object parentId = parent.id();
    for (Iterator<T> ite = nodes.iterator(); ite.hasNext(); ) {
      T node = ite.next();
      if (Objects.equals(node.parentId(), parentId)) {
        children.add(node);
        // 從所有節點列表中刪除該節點，以免後續重複遍歷該節點
        ite.remove();
      }
    }
    // 如果孩子為空，則直接返回,否則繼續遞迴設定孩子的孩子
    if (children.isEmpty()) {
      return;
    }
    parent.setChildren(children);
    children.forEach(m -> {
      // 遞迴設定子節點
      setChildren(m, nodes);
    });
  }
  /**
   * 獲取指定樹節點下的所有葉子節點
   *
   * @param parent 父節點
   * @param <T>  實際節點型別
   * @return 葉子節點
   */
  public static <T extends TreeNode<?>> List<T> getLeafs(T parent) {
    List<T> leafs = new ArrayList<>();
    fillLeaf(parent, leafs);
    return leafs;
  }
  /**
   * 將parent的所有葉子節點填充至leafs列表中
   *
   * @param parent 父節點
   * @param leafs 葉子節點列表
   * @param <T>  實際節點型別
   */
  @SuppressWarnings("all")
  public static <T extends TreeNode> void fillLeaf(T parent, List<T> leafs) {
    List<T> children = parent.getChildren();
    // 如果節點沒有子節點則說明為葉子節點
    if (CollectionUtils.isEmpty(children)) {
      leafs.add(parent);
      return;
    }
    // 遞迴呼叫子節點，查詢葉子節點
    for (T child : children) {
      fillLeaf(child, leafs);
    }
  }
}

@Getter
@Setter
public class ResourceListVO implements TreeNode<Long> {
  private Long id;
  private Long pid;
  private Integer type;
  private String name;
  private String icon;
  private String code;
  private Integer status;
  private List<ResourceListVO> children;
  @Override
  public Long id() {
    return this.id;
  }
  @Override
  public Long parentId() {
    return this.pid;
  }
  @Override
  public boolean root() {
    return Objects.equals(this.pid, 0L);
  }
  @Override
  public void setChildren(List children) {
    this.children = children;
  }
}

 /**
  * 獲取賬號的資源樹
  */
  public List<ResourceListVO> listByAccountId(Long accountId) {
    return TreeUtils.generateTrees(BeanUtils.copyProperties(mapper.selectByAccountId(userId), ResourceListVO.class));
  }

package com.lming.chcservice.util; 
import lombok.Data; 
import java.util.List;
@Data
public class TreeNode {
  /**
   * 節點id
   */
  private String id;
  /**
   * 父節點 預設0為根節點
   */
  private String parentId;
  /**
   * 節點名稱
   */
  private String name;
  /**
   * 是否有子節點
   */
  private boolean hasChild;
 
  public TreeNode(String id, String parentId, String name) {
    this.id = id;
    this.parentId = parentId;
    this.name = name;
  }
}

package com.lming.chcservice.util;
 
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
 
/**
 * 樹形結構工具類
 *
 * 將一組list物件轉成樹形結構
 * 該list需符合設定的欄位型別
 *
 */
public class TreeUtil { 
 
  public static Map<String,Object> mapArray = new LinkedHashMap<String, Object>(); 
  public List<TreeNode> menuCommon;
  public List<Object> list = new ArrayList<Object>();
 
  public List<Object> treeMenu(List<TreeNode> menu){
    this.menuCommon = menu;
    for (TreeNode treeNode : menu) {
      Map<String,Object> mapArr = new LinkedHashMap<String, Object>();
      if(treeNode.getParentId().equals("0")){
        setTreeMap(mapArr,treeNode);
        list.add(mapArr);
      }
    }
    return list;
  }
 
  public List<?> menuChild(String id){
    List<Object> lists = new ArrayList<Object>();
    for(TreeNode a:menuCommon){
      Map<String,Object> childArray = new LinkedHashMap<String, Object>();
      if(a.getParentId() .equals(id)){
        setTreeMap(childArray,a);
        lists.add(childArray);
      }
    }
    return lists;
  }
 
  private void setTreeMap(Map<String,Object> mapArr,TreeNode treeNode){
    mapArr.put("id", treeNode.getId());
    mapArr.put("name", treeNode.getName());
    mapArr.put("parentId", treeNode.getParentId());
    List<?> childrens = menuChild(treeNode.getId());
    if(childrens.size()>0){
      mapArr.put("hasChild",true);
    }
    else{
      mapArr.put("hasChildren",false);
    }
    mapArr.put("childrens", menuChild(treeNode.getId()));
  }
 
  public static void main(String[] args){
 
    List<TreeNode> treeNodeList = new ArrayList<>();
    TreeNode treeNode1 = new TreeNode("1","0","首頁");
    TreeNode treeNode2 = new TreeNode("2","0","訂單");
    TreeNode treeNode3 = new TreeNode("3","1","預約");
    TreeNode treeNode4 = new TreeNode("4","2","捐獻");
    TreeNode treeNode5 = new TreeNode("5","4","我的訂單");
    TreeNode treeNode6 = new TreeNode("6","5","個人中心");
    TreeNode treeNode7 = new TreeNode("7","6","個人中心2");
    TreeNode treeNode8 = new TreeNode("8","99","個人中心3");
    treeNodeList.add(treeNode1);
    treeNodeList.add(treeNode6);
    treeNodeList.add(treeNode5);
    treeNodeList.add(treeNode3);
    treeNodeList.add(treeNode4);
    treeNodeList.add(treeNode2);
    treeNodeList.add(treeNode7);
    treeNodeList.add(treeNode8); 
 
    TreeUtil treeUtil = new TreeUtil();
    System.out.print(JsonUtil.toJson(treeUtil.treeMenu(treeNodeList))); 
  } 
}

[
 {
  "id": "1",
  "name": "首頁",
  "parentId": "0",
  "hasChild": true,
  "childrens": [
   {
    "id": "3",
    "name": "預約",
    "parentId": "1",
    "hasChildren": false,
    "childrens": []
   }
  ]
 },
 {
  "id": "2",
  "name": "訂單",
  "parentId": "0",
  "hasChild": true,
  "childrens": [
   {
    "id": "4",
    "name": "捐獻",
    "parentId": "2",
    "hasChild": true,
    "childrens": [
     {
      "id": "5",
      "name": "我的訂單",
      "parentId": "4",
      "hasChild": true,
      "childrens": [
       {
        "id": "6",
        "name": "個人中心",
        "parentId": "5",
        "hasChild": true,
        "childrens": [
         {
          "id": "7",
          "name": "個人中心2",
          "parentId": "6",
          "hasChildren": false,
          "childrens": []
         }
        ]
       }
      ]
     }
    ]
   }
  ]
 }
]