研究将有pid和id的List<Map<String,Map>>组成树

树如图所示：

方法一：用递归的方法，思路清晰但效率很慢并且不灵活：

思路：递归查询，使用深度优先算法，第一遍找A-->B-->D,将D加到B中，再找B->E,将E加到B中，然后将B加到A中，然后找到A-->C-->F-->G,将G加到F中，将F加到C中，将C加到A中。

    /** 
     * 递归生成树
     * 方法详细描述
     *
     * @author 龙谷情
     * @date 2021/3/31 17:47
     * @param [list, pid, idNm, pidNm] 要处理的集合，很节点的父级id，id的键名，父级id的键名
     * @return java.util.List<java.util.Map<java.lang.String,java.lang.Object>>[返回类型说明]
     * @exception/throws [异常类型] [异常说明]
     * @since [v1.0]
     */
    public static List<Map<String, Object>> getTreeRecursion(List<Map<String, Object>> list, String pid, String idNm, String pidNm) {
        List<Map<String, Object>> res = new ArrayList<Map<String, Object>>();
        if (CollectionUtils.isNotEmpty(list)) {
            for (Map<String, Object> map : list) {
                if ((pid == null && map.get(pidNm) == null) || (map.get(pidNm) != null && map.get(pidNm).equals(pid))) {
                    String id = (String) map.get(idNm);
                    map.put("children", getTreeRecursion(list, id, idNm,pidNm));
                    res.add(map);
                }
            }
        }
        return res;
    }

方法二：通过具体的地址索引进行生成，不用多次对list进行循环查询，效率较高

思路：遍历list，将每个节点的父级id作为key，value是一个数组，保存自己和有相同父级id的其他节点，假设此map为treeNoteListMap，如果是根节点，保存到一个map中，设为tree，如果不是，则继续往下进行，查询treeNoteListMap中的key和此节点id相同的数组元素，将这个元素添加到这个节点下，如果没有，添加一个空的数组，遍历一遍，即可通过索引将树生成

    /** 
     * 不通过递归进行查询
     * 方法详细描述
     *
     * @author 赵学壮
     * @date 2021/3/31 17:56
     * @param [rootId, noteList, pidName, idName] 根节点id，待处理集合，id的键名，父级id的键名
     * @return java.util.Map[返回类型说明]
     * @exception/throws [异常类型] [异常说明]
     * @since [v1.0]
     */
    private static Map getTree(String rootId, List<Map<String, Object>> noteList,String pidName,String idName) {

        Map tree = null;
        Map<String,List<Map<String,Object>>> treeNoteListMap = new HashMap<>(16);
        for (Map<String,Object> note:noteList){
            if (rootId.equals(note.get(idName))){
                tree = note;
            }
            if (StringUtils.isNotBlank(note.get(pidName).toString())){
                List<Map<String,Object>> mapList = treeNoteListMap.get(note.get(pidName).toString());
                if (null==mapList){
                    mapList = new ArrayList<>();
                }
                mapList.add(note);
                treeNoteListMap.put(note.get(pidName).toString(),mapList);
            }
            if (null == treeNoteListMap.get(note.get(idName))){
                treeNoteListMap.put(note.get(idName).toString(),new ArrayList<>());
            }
            note.put("children",treeNoteListMap.get(note.get(idName)));
        }
        return tree;
    }

 测试：

一：小数据测试：

测试代码如下：

public static void main(String[] args) {
        String inId = "ida";
        List<Map<String,Object>> noteList = new ArrayList<>();
        Map<String,Object> note0 = new HashMap<>(16);
        note0.put("id","ida");
        note0.put("pid","");
        note0.put("name","A");
        noteList.add(note0);

        Map<String,Object> note1 = new HashMap<>(16);
        note1.put("id","idb");
        note1.put("pid","ida");
        note1.put("name","B");
        noteList.add(note1);

        Map<String,Object> note2 = new HashMap<>(16);
        note2.put("id","idc");
        note2.put("pid","ida");
        note2.put("name","C");
        noteList.add(note2);

        Map<String,Object> note5 = new HashMap<>(16);
        note5.put("id","idf");
        note5.put("pid","idc");
        note5.put("name","F");
        noteList.add(note5);

        Map<String,Object> note6 = new HashMap<>(16);
        note6.put("id","idg");
        note6.put("pid","idf");
        note6.put("name","G");
        noteList.add(note6);

        Map<String,Object> note3 = new HashMap<>(16);
        note3.put("id","idd");
        note3.put("pid","idb");
        note3.put("name","D");
        noteList.add(note3);

        Map<String,Object> note4 = new HashMap<>(16);
        note4.put("id","ide");
        note4.put("pid","idb");
        note4.put("name","E");
        noteList.add(note4);


        Long l1 = System.currentTimeMillis();
        Map tree = getTree(inId,noteList,"pid","id");
        Long l2 = System.currentTimeMillis();
        System.out.println(l2-l1);
        JSONObject object = new JSONObject(tree);
        System.out.println(object);


        Long l3 = System.currentTimeMillis();
        List<Map<String, Object>> treeRecursionList = getTreeRecursion(noteList,"","id","pid");
        Long l4 = System.currentTimeMillis();
        System.out.println(l4-l3);
        JSONObject objectRecursion = new JSONObject(treeRecursionList.get(0));
        System.out.println(objectRecursion);
    }

将获得的json结果格式化得到：

{
    "children": [{
        "children": [{
            "children": [],
            "name": "D",
            "pid": "idb",
            "id": "idd"
        }, {
            "children": [],
            "name": "E",
            "pid": "idb",
            "id": "ide"
        }],
        "name": "B",
        "pid": "ida",
        "id": "idb"
    }, {
        "children": [{
            "children": [{
                "children": [],
                "name": "G",
                "pid": "idf",
                "id": "idg"
            }],
            "name": "F",
            "pid": "idc",
            "id": "idf"
        }],
        "name": "C",
        "pid": "ida",
        "id": "idc"
    }],
    "name": "A",
    "pid": "",
    "id": "ida"
}