java的List列表转成Tree（树形）结构列表

直接看借鉴博客：https://blog.csdn.net/massivestars/article/details/53911620/

 

第一种：List<Object对象>转成tree树形结构

由于我的业务没有父子级id两个字段，只有一个层级id字段来分层，如一级数据：01，02，03...，二级数据：0101，0102，0103，0201，...，三级数据：010101，010102...等等，但思路是一样的，我用的是两个for循环搞定，如下：

/**
     * @Description：list转tree（树形方法）
     * @Author：
     * @Date：2018/12/16 16:19
     **/
    public static List<WkgGroupVo> listToTree(List<WkgGroupVo> wkgGroupVoList){
        List<WkgGroupVo> wkgGroupVoTree = new ArrayList<WkgGroupVo>();
        for(WkgGroupVo wgVo : wkgGroupVoList){

            //层级字段数据为两位数，则是一级数据
            if(wgVo.getGpStructurecode().length() == 2){
                wkgGroupVoTree.add(wgVo);
            }

            //循环出子级数据，添加到一级数据
            for(WkgGroupVo subWgVo : wkgGroupVoList){
                int len = subWgVo.getGpStructurecode().length();
                String gpStructurecode = subWgVo.getGpStructurecode().substring(0, len -2);
                if(gpStructurecode.equals(wgVo.getGpStructurecode())){
                    if(wgVo.getWgList() == null){
                        wgVo.setWgList(new ArrayList<WkgGroupVo>());
                    }
                    wgVo.getWgList().add(subWgVo);
                }
            }

        }

        return wkgGroupVoTree;
    }

 

 

第二种：List<Map>转成tree树形结构：亲测没什么问题，根据自己的业务来修改细节代码

借鉴博客：https://blog.csdn.net/M_amazing/article/details/120079121

public class OuterDemo {

    public static void main(String[] args) {

        //  下面是测试的数据，大概的结构是
        // label01->label03->label04
        //        ->label06
        // label02->label->05
        Map<String, Object> map1 = new HashMap<>();
        map1.put("label", "lala01");
        map1.put("pid", "0");
        map1.put("id", "1");
        Map<String, Object> map2 = new HashMap<>();
        map2.put("label", "lala02");
        map2.put("pid", "0");
        map2.put("id", "2");
        Map<String, Object> map3 = new HashMap<>();
        map3.put("label", "lala03");
        map3.put("pid", "1");
        map3.put("id", "3");
        Map<String, Object> map4 = new HashMap<>();
        map4.put("label", "lala04");
        map4.put("pid", "3");
        map4.put("id", "4");
        Map<String, Object> map5 = new HashMap<>();
        map5.put("label", "lala05");
        map5.put("pid", "2");
        map5.put("id", "5");
        Map<String, Object> map6 = new HashMap<>();
        map6.put("label", "lala06");
        map6.put("pid", "1");
        map6.put("id", "6");

        // 将测试数据放到List中，模拟数据库返回值
        List<Map<String, Object>> list = new LinkedList<>();
        list.add(map1);
        list.add(map2);
        list.add(map3);
        list.add(map4);
        list.add(map5);
        list.add(map6);
        System.out.println(list);
        //    开始写递归的方法

        // 第一层的的数据，在这里就是 label01 和 label02单独抽取出来，因为有时候需要单独处理，也可以将for循环的代码放到递归的位置一起处理
        List<Map<String, Object>> level1List = new ArrayList<>();
        for (Map<String, Object> map : list) {
            if (map.get("pid") == "0") {
                level1List.add(map);
            }
        }
        //    最终返回前台的数据 List
        List<Map<String, Object>> finaList = new ArrayList<>();
        // 一个临时数据tmpMap，用来做临时交换数据
        Map<String, Object> tmpMap;
        // 遍历第一层，给他塞数据，赛Children的时候进行递归
        for (Map<String, Object> map : level1List) {
            //这里要生成一个新的HashMap
            tmpMap = new HashMap<>();
            tmpMap.put("id", map.get("id"));
            tmpMap.put("pid", map.get("pid"));
            tmpMap.put("label", map.get("label"));
            // 这里的 ifHasChild 是为了加快程序运行，如果没孩子就别递归了，直接下一个兄弟节点
            if (ifHasChild((String) map.get("id"), list)) {
                // 最主要的一步，递归，找到孩子节点，然后塞到Map中
                tmpMap.put("Children", getChildren(tmpMap, list));
            }
            
            finaList.add(tmpMap);

        }
        //    打印一下
        System.out.println("最终的结果：------------------");
        System.out.println(finaList);

    }


    // 递归程序
    public static List<Map<String, Object>> getChildren(Map<String, Object> map, List<Map<String, Object>> list) {
        List<Map<String, Object>> mapList = new ArrayList<>();
        Map<String, Object> tmMap;
        for (Map<String, Object> tmpMap : list) {

            if (tmpMap.get("pid").equals(map.get("id"))) {
                tmMap = new HashMap<>();
                tmMap.put("id", tmpMap.get("id"));
                tmMap.put("pid", tmpMap.get("pid"));
                tmMap.put("label", tmpMap.get("label"));
                //  递归代码
                if (ifHasChild((String) tmpMap.get("id"), list)) {
                    tmMap.put("Children", getChildren(tmMap, list));
                }

                mapList.add(tmMap);
            }
        }

        // 递归返回条件，如果没返回条件就死循环了
        if (mapList.size() == 0) {
            //没有子节点情况下
            return null;
        } else {
            return mapList;
        }

    }

    //    判断一个Map是否有子节点,加快程序运行
    public static boolean ifHasChild(String id, List<Map<String, Object>> list) {
        int result = 0;
        for (Map<String, Object> map : list) {
            if (map.get("pid") != null && map.get("pid").equals(id)) {
                result++;
            }
        }
        return result > 0 ? true : false;
    }
}

 

 

输出结果：

[{pid=0, id=1, label=lala01, Children=[
    {pid=1, id=3, label=lala03, Children=[
        {pid=3, id=4, label=lala04}
        ]},
    {pid=1, id=6, label=lala06}]}, 
 {pid=0, id=2, label=lala02, Children=[
    {pid=2, id=5, label=lala05}]}]

 

 

 

 

 

 

 

 

 

 

。