java返回树结构数据

方法1、

SELECT
	si.id,
	si.pid,
	si.last_level_name lastLevelName
FROM
	tf_store_info si
id     pid    name
2122	0	**有限公司
2123	2122	hx
2133	2122	测试2
2134	2133	测试3
2135	2133	测试4
2136	2135	测试5
2137	2135	测试6
以上sql是查 list数据

setStoreTreeList(0,list,treeList);

/**
     * 默认父级id为0的树形数据
     */
    private void setStoreTreeList(Integer parentId, List<Map<String,Object>> list, List<Map<String,Object>> treeList) {
        for (Map<String,Object> map : list) {
            if(map.get("pid")!=null){
                Integer rcsParentId = Integer.parseInt(String.valueOf(map.get("pid")));
                if(parentId.equals(rcsParentId)){
                    treeList.add(map);
                    Integer id = Integer.parseInt(String.valueOf(map.get("id")));
                    if (list.stream().filter(r ->r.get("pid")!=null && r.get("pid").equals(id.toString())).findAny() !=null){
                        List<Map<String, Object>> childList = new ArrayList<>();
                        map.put("child",childList);
                        setStoreTreeList(id,list,childList);
                    }
                }
            }
        }
    }

　　

方法2、

一、创建一个实体类

package com.example.demo.evt;

import lombok.Data;

import java.util.List;
@Data
public class UserTree {
    private String id;
    private String label;
    private String sort;
    private String pid;
    private List<UserTree> child;

    public UserTree(String id, String label, String sort, String pid, List<UserTree> child) {
        this.id = id;
        this.label = label;
        this.sort = sort;
        this.pid = pid;
        this.child = child;
    }

    public String getId() {
        return id;
    }

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

    public String getLabel() {
        return label;
    }

    public void setLabel(String label) {
        this.label = label;
    }

    public String getSort() {
        return sort;
    }

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

    public String getPid() {
        return pid;
    }

    public void setPid(String pid) {
        this.pid = pid;
    }

    public List<UserTree> getChild() {
        return child;
    }

    public void setChild(List<UserTree> child) {
        this.child = child;
    }
}

二、创建一个util类

package com.example.demo.utils;

import com.example.demo.evt.UserTree;
import org.assertj.core.util.Lists;

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

public class TreeToolUtils {
    private List<UserTree> rootList; //根节点对象存放到这里

    private List<UserTree> bodyList; //其他节点存放到这里，可以包含根节点

    public TreeToolUtils(List<UserTree> rootList, List<UserTree> bodyList) {
        this.rootList = rootList;
        this.bodyList = bodyList;
    }

    public List<UserTree> getTree(){   //调用的方法入口
        if(bodyList != null && !bodyList.isEmpty()){
            //声明一个map，用来过滤已操作过的数据
//            Map<String,String> map = Maps.newHashMapWithExpectedSize(bodyList.size());
            Map<String,String> map = new HashMap<>();
                    rootList.forEach(beanTree -> getChild(beanTree,map));
            return rootList;
        }
        return null;
    }

    public void getChild(UserTree treeDto,Map<String,String> map){
        List<UserTree> childList = Lists.newArrayList();
        bodyList.stream()
                .filter(c -> !map.containsKey(c.getId()))
                .filter(c ->c.getPid().equals(treeDto.getId()))
                .forEach(c ->{
                    map.put(c.getId(),c.getPid());
                    getChild(c,map);
                    childList.add(c);
                });
        treeDto.setChild(childList);

    }


}

三、main 测试

public static void main(String[] args) {
　　　　　// id, label, sort, pid, List<UserTree>　可以是返回的数据，然后遍历add到数组中
        UserTree treeDto = new UserTree("1", "北京", "null", "true",null);
        UserTree treeDto1 = new UserTree("2", "三环", "null", "1",null);
        UserTree treeDto2 = new UserTree("3", "故宫", "null", "1",null);
        UserTree treeDto3 = new UserTree("710", "陈静", "null", "2",null);
        UserTree treeDto4= new UserTree("713", "秀秀", "null", "2",null);
        ArrayList<UserTree> rootList = new ArrayList<>();//根节点
        ArrayList<UserTree> bodyList = new ArrayList<>();//子节点
        rootList.add(treeDto);
        bodyList.add(treeDto1);
        bodyList.add(treeDto2);
        bodyList.add(treeDto3);
        bodyList.add(treeDto4);

        System.out.println(bodyList.get(1));
        TreeToolUtils utils =  new TreeToolUtils(rootList,bodyList);
        List<UserTree> result =  utils.getTree();
        String jsonString = JSONObject.toJSONString(result.get(0));
        System.out.println(jsonString);
}

 如果是serviceImpl返回的数据

try {

            logger.log(MyLogUtil.LOG_INFO,"获取配置");
            List<Map<String,Object>> list = precisePushMapper.queryCommitConfigOne();
            List<Map<String,Object>> resultList = new ArrayList<>();
            // 转为树结构为前端使用
            if(list.size() > 0){
                ArrayList<ConfigTree> rootList = new ArrayList<>();//根节点
                ArrayList<ConfigTree> bodyList = new ArrayList<>();//子节点
                for(int i=0;i<list.size();i++){
                    String configId = list.get(i).get("configId").toString();
                    String configName = list.get(i).get("configName").toString();
                    String pid = list.get(i).get("pid").toString();
                    ConfigTree tree = new ConfigTree(configId,configName,pid,null);
                    if(pid.equals("true") || pid == "" || pid == null){ // 说明是根节点
                        rootList.add(tree);
                    }else {
                        bodyList.add(tree);
                    }
                }
                ConfigTreeUtil utils =  new ConfigTreeUtil(rootList,bodyList);
                List<ConfigTree> result =  utils.getTree();
                for(int i=0;i<result.size();i++){ // 转换一下格式，前端能使用
                    String str =  JSONObject.toJSONString(result.get(i));
                    Map<String, Object> map = JSONObject.parseObject(str, new TypeReference<Map<String, Object>>() {});
                    resultList.add(map);
                }
            }
            return resp.success(resultList);
        } catch (Exception e) {
            logger.log(MyLogUtil.LOG_ERROR,"获取失败！",e);
            return resp.error("获取失败！");
        }

数据库查询的数据结构

 

方法三：

控制层：

/**
     * 获取树形结构
     */
    @PostMapping("/getTreeDgInfolist")
    public AjaxResult getTreeDgInfolist(BsDgInfo bsDgInfo)
    {
        List<BsDgInfo> treeDgInfolist = bsDgInfoService.selectBsDgInfoList(bsDgInfo);
        List<TreeSelectData> treeList = bsDgInfoService.buildDgTreeSelect(treeDgInfolist);
        return success(treeList);
    }

 

实现层：

@Override
    public List<TreeSelectData> buildDgTreeSelect(List<BsDgInfo> treeDgInfolist) {
        List<BsDgInfo> dgTrees = buildDgInfoTree(treeDgInfolist);
        return dgTrees.stream().map(TreeSelectData::new).collect(Collectors.toList());
    }

    /**
     * 构建前端所需要树结构
     *
     * @param treeDgInfolist 菜单列表
     * @return 树结构列表
     */
    public List<BsDgInfo> buildDgInfoTree(List<BsDgInfo> treeDgInfolist)
    {
        List<BsDgInfo> returnList = new ArrayList<BsDgInfo>();
        List<Long> tempList = treeDgInfolist.stream().map(BsDgInfo::getDgId).collect(Collectors.toList());
        for (Iterator<BsDgInfo> iterator = treeDgInfolist.iterator(); iterator.hasNext();)
        {
            BsDgInfo bsDgInfo = (BsDgInfo) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(bsDgInfo.getParentId()))
            {
                recursionFn(treeDgInfolist, bsDgInfo);
                returnList.add(bsDgInfo);
            }
        }
        if (returnList.isEmpty())
        {
            returnList = treeDgInfolist;
        }
        return returnList;
    }

    /**
     * 递归列表
     *
     * @param list 分类表
     * @param t 子节点
     */
    private void recursionFn(List<BsDgInfo> list, BsDgInfo t)
    {
        // 得到子节点列表
        List<BsDgInfo> childList = getChildList(list, t);
        t.setChildren(childList);
        for (BsDgInfo tChild : childList)
        {
            if (hasChild(list, tChild))
            {
                recursionFn(list, tChild);
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private List<BsDgInfo> getChildList(List<BsDgInfo> list, BsDgInfo t)
    {
        List<BsDgInfo> tlist = new ArrayList<BsDgInfo>();
        Iterator<BsDgInfo> it = list.iterator();
        while (it.hasNext())
        {
            BsDgInfo n = (BsDgInfo) it.next();
            if (n.getParentId().longValue() == t.getDgId().longValue())
            {
                tlist.add(n);
            }
        }
        return tlist;
    }

    /**
     * 判断是否有子节点
     */
    private boolean hasChild(List<BsDgInfo> list, BsDgInfo t)
    {
        return getChildList(list, t).size() > 0;
    }

 

Treeselect树结构实体类

package com.ruoyi.bidDocument.domain;

import com.fasterxml.jackson.annotation.JsonInclude;

import java.io.Serializable;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Treeselect树结构实体类
 * 
 * @author ruoyi
 */
public class TreeSelectData implements Serializable
{
    private static final long serialVersionUID = 1L;

    /** 节点ID */
    private Long id;

    /** 节点名称 */
    private String label;

    private String desc;

    /** 节点禁用 */
    private boolean disabled = false;

    /** 子节点 */
    @JsonInclude(JsonInclude.Include.NON_EMPTY)
    private List<TreeSelectData> children;

    public TreeSelectData()
    {

    }

    public TreeSelectData(BsDgInfo dgInfo)
    {
        this.id = dgInfo.getDgId();
        this.label = dgInfo.getDgTitle();
        this.desc = dgInfo.getDgDesc();
        this.children = dgInfo.getChildren().stream().map(TreeSelectData::new).collect(Collectors.toList());
    }

    public Long getId()
    {
        return id;
    }

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

    public String getLabel()
    {
        return label;
    }

    public void setLabel(String label)
    {
        this.label = label;
    }

    public boolean isDisabled()
    {
        return disabled;
    }

    public void setDisabled(boolean disabled)
    {
        this.disabled = disabled;
    }

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

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

    public String getDesc()
    {
        return desc;
    }

    public void setDesc(String desc)
    {
        this.desc = desc;
    }
}