樹形結構tree工具類

說明：下面用到了lombox插件，和hutool工具包，這兩個自行百度

 

TreeBean.class  用來封裝樹形結構的實體類

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
 *  
 *  * @projectName vcsrm-parent
 *  * @title     TreeBean   
 *  * @package    com.clfps.entity.result  
 *  * @description    樹形結構表類
 *  * @author IT_CREAT     
 *  * @date  2019 2019/7/1 13:39  
 *  * @version V1.0.0 
 *  
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class TreeBean implements Serializable {

    private static final long serialVersionUID = 1L;


    /*id和pid必須賦值，otherParameter裝一些其他參數，比如name，key-value鍵值對的形式*/
    /*將你從數據庫查出來的集合循環，然後對每一行數據進行賦值轉換成TreeBean結構，調用TreeUtils工具即可得到樹形結構列表*/
    private Long id;//id

    private Long pid;//pid

    private Map<String, Object> otherParameter;//其他參數，需要展示的參數,比如name之類的


    /*---------------------------------下面這些不需要你賦值-------------------------------------------*/
    private Boolean hasChildren;//是否含有下一級

    private List<TreeBean> children;//包含的子節點

    private Long childrenSize;//子節點的集合大小

    private Long level;//級別

}

 

TreeUtils.class 用來構造樹形結構的工具類

import cn.hutool.core.util.NumberUtil;
import com.xxxx.utils.bean.TreeBean;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

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

/**
 *  
 *  * @projectName vcsrm-parent
 *  * @title     TreeUtils   
 *  * @package    com.clfps.utils  
 *  * @description    樹形結構utils
 *  * @author IT_CREAT     
 *  * @date  2019 2019/7/1 15:39  
 *  * @version V1.0.0 
 *  
 */
public class TreeUtils {

    /**
     * 使用遞歸方法建樹
     * @param treeBeans 按規則轉換的樹形實體集合列表，沒有層次結構
     * @param topId 指定頂級節點id，必須指定
     * @param topTreeBean 指定頂級節點構造的樹形實體，可以傳入空值，但是傳入空值會將頂級節點的數據去除，返回指定頂級節點的子節點樹形結構集合
     * @return 樹形結構實體集合
     */
    public static List<TreeBean> buildByRecursive(List<TreeBean> treeBeans, Long topId ,TreeBean topTreeBean) {
        List<TreeBean> trees = new ArrayList<>();
        TreeBean treeBeanTop = null;
        for (TreeBean treeBean : treeBeans) {
            if (0 == NumberUtil.compare(treeBean.getPid(),topId)) {
                Long level = 1L;
                if(!ObjectUtils.isEmpty(topTreeBean) && 0 == NumberUtil.compare(topTreeBean.getId(), topId)){
                    level = 2L;
                }
                TreeBean treeBean2 = findChildren(treeBean,treeBeans,level);
                if(CollectionUtils.isEmpty(treeBean2.getChildren())){
                    treeBean2.setHasChildren(false);
                    treeBean2.setLevel(level);
                }else {
                    treeBean2.setHasChildren(true);
                    treeBean2.setLevel(level);
                    treeBean2.setChildrenSize((long) treeBean2.getChildren().size());
                }
                trees.add(treeBean2);
            }else if(!ObjectUtils.isEmpty(topTreeBean) && 0 == NumberUtil.compare(treeBean.getId(), topId)){
                treeBeanTop = treeBean;
            }
        }
        if(!ObjectUtils.isEmpty(treeBeanTop)){
            treeBeanTop.setChildren(trees)
                .setChildrenSize((long) trees.size())
                .setHasChildren(true)
                .setLevel(1L);
            trees = new ArrayList<>();
            trees.add(treeBeanTop);
        }
        return trees;
    }


    /**
     * 遞歸查找子節點
     * @param
     * @return
     */
    private static TreeBean findChildren(TreeBean treeBean,List<TreeBean> treeBeans,Long level) {
        for (TreeBean it : treeBeans) {
            if(0 == NumberUtil.compare(treeBean.getId(), it.getPid())) {
                if (treeBean.getChildren() == null) {
                    treeBean.setChildren(new ArrayList<>());
                }
                TreeBean treeBean2 = findChildren(it,treeBeans,level+1);
                if(!CollectionUtils.isEmpty(treeBean2.getChildren())){
                    treeBean2.setHasChildren(true);
                    treeBean2.setChildrenSize((long) treeBean.getChildren().size());
                    treeBean2.setLevel(level+1);
                }else if(treeBean2.getChildren() == null || treeBean2.getChildren().size() == 0){
                    treeBean2.setHasChildren(false);
                    treeBean2.setLevel(level+1);
                }
                treeBean.getChildren().add(treeBean2);
            }
        }
        return treeBean;
    }


    public static void main(String[] args) {
        TreeBean treeBean = new TreeBean();
        treeBean.setId(1L);
        treeBean.setPid(6000L);
//        treeBean.setLevel(1);
        Map<String, Object> parameter = new HashMap<>();
        parameter.put("name", "sadasda");
        parameter.put("nameEn", "sadasda");
        parameter.put("namePinyin", "sadasda");
        parameter.put("code", "sadasda");
        treeBean.setOtherParameter(parameter);

        TreeBean treeBean2 = new TreeBean();
        treeBean2.setId(2L);
        treeBean2.setPid(6000L);
//        treeBean2.setLevel(1);
        Map<String, Object> parameter2 = new HashMap<>();
        parameter.put("name", "sadasda");
        parameter.put("nameEn", "sadasda");
        parameter.put("namePinyin", "sadasda");
        parameter.put("code", "sadasda");
        treeBean2.setOtherParameter(parameter);

        TreeBean treeBean3 = new TreeBean();
        treeBean3.setId(3L);
        treeBean3.setPid(1L);
//        treeBean3.setLevel(2);
        Map<String, Object> parameter3 = new HashMap<>();
        parameter.put("name", "sadasda");
        parameter.put("nameEn", "sadasda");
        parameter.put("namePinyin", "sadasda");
        parameter.put("code", "sadasda");
        treeBean3.setOtherParameter(parameter);

        TreeBean treeBean4 = new TreeBean();
        treeBean4.setId(4L);
        treeBean4.setPid(1L);
//        treeBean4.setLevel(2);
        Map<String, Object> parameter4 = new HashMap<>();
        parameter.put("name", "sadasda");
        parameter.put("nameEn", "sadasda");
        parameter.put("namePinyin", "sadasda");
        parameter.put("code", "sadasda");
        treeBean4.setOtherParameter(parameter);

        TreeBean treeBean5 = new TreeBean();
        treeBean5.setId(5L);
        treeBean5.setPid(3L);
//        treeBean5.setLevel(3);
        Map<String, Object> parameter5 = new HashMap<>();
        parameter.put("name", "sadasda");
        parameter.put("nameEn", "sadasda");
        parameter.put("namePinyin", "sadasda");
        parameter.put("code", "sadasda");
        treeBean5.setOtherParameter(parameter);

        List<TreeBean> treeBeans = new ArrayList<>();
        treeBeans.add(treeBean);
        treeBeans.add(treeBean2);
        treeBeans.add(treeBean3);
        treeBeans.add(treeBean4);
        treeBeans.add(treeBean5);

        System.out.println(buildByRecursive(treeBeans,6000L,null));

    }
}

 

例子：

表現層：

@ApiOperation("資產分類樹形結構")
@PostMapping("/tree")
public JsonResult treeList(Long assetsSortId){
     if(ObjectUtils.isEmpty(assetsSortId)){
         assetsSortId = 1L;
     }
     //根據傳入的資產id查詢出包括該資產分類及其子節點分類的集合
     List<AssetsSort> assetsSortList = assetsSortService.selectAssetsSortList((new AssetsSort()).setAssetsSortId(assetsSortId));
     List<TreeBean> treeBeans = assetsSortService.buildTree(assetsSortList, assetsSortId);
     return new JsonResult(treeBeans);
}

業務層：

/**
     * 樹形結構
     * @param assetsSorts 查詢出集合
     * @param assetsSortId 頂級節點id
     * @return
     */
    public List<TreeBean> buildTree(List<AssetsSort> assetsSorts,Long assetsSortId) {
        ArrayList<TreeBean> treeBeans = new ArrayList<>();//將資產分類轉換成樹形實體的集合
        List<TreeBean> treeBeans1 = new ArrayList<>();//要返回的樹形結構集合
        if(!CollectionUtils.isEmpty(assetsSorts)){
            Long topId = 1L;//設置默認頂級節點爲1，也就是資產分類id的最頂級爲1
            TreeBean assetsSortBean  =null;
            //循環資產分類，將資產分類對象轉換爲樹形實體
            for(AssetsSort assetsSort:assetsSorts){
                TreeBean treeBean = new TreeBean();
                treeBean.setId(assetsSort.getAssetsSortId());
                treeBean.setPid(assetsSort.getParentId());
                Map<String, Object> parameter = new HashMap<>();
                parameter.put("assetsSortName", assetsSort.getAssetsSortName());
                parameter.put("assetsSortNames", assetsSort.getAssetsSortNames());
                parameter.put("parentIds", assetsSort.getParentIds());
                parameter.put("createBy", assetsSort.getCreateBy());
                parameter.put("createTime", ObjectUtils.isEmpty(assetsSort.getCreateTime()) ? "":DateUtils.parseDateToStr("yyyy-MM-dd hh:mm:ss",assetsSort.getCreateTime()));
                parameter.put("updateBy", assetsSort.getUpdateBy());
                parameter.put("updateTime", ObjectUtils.isEmpty(assetsSort.getUpdateTime()) ? "":DateUtils.parseDateToStr("yyyy-MM-dd hh:mm:ss",assetsSort.getUpdateTime()));
                parameter.put("deleteFlag", assetsSort.getDeleteFlag());
                treeBean.setOtherParameter(parameter);
                treeBeans.add(treeBean);//將轉換成的樹形實體添加進集合
                //拿到頂級節點
                if ((!ObjectUtils.isEmpty(assetsSortId)&&NumberUtil.compare(assetsSortId,assetsSort.getAssetsSortId())==0)
                        || NumberUtil.compare(topId,assetsSort.getAssetsSortId())==0){
                    assetsSortBean = treeBean;
                }
            }
            if(!ObjectUtils.isEmpty(assetsSortId)){
                topId = assetsSortId;//將傳入的資產分類id作爲頂級節點
            }
            //利用工具類構造成樹形結構
            treeBeans1 = TreeUtils.buildByRecursive(treeBeans, topId,assetsSortBean);
        }
        return treeBeans1;
    }