list集合转tree树工具

public class TreeUtils {

    private static final String ROOT_ID = "0";
    private static final String GET = "get";
    private static final String SET = "set";

    /**
     * 私有构造器
     */
    private TreeUtils() {
        throw new IllegalStateException("Utility class");
    }

    /**
     * list集合转tree树（不用递归）
     * @param list         需要转化树形的list
     * @param idName       实体类中id的属性名(首字母需要大写,例如属性为id,则传Id)
     * @param parentIdName 实体类中父id的属性名(首字母需要大写,例如属性为parentId,则传ParentId)
     * @param childrenName 实体类中封装树形的子list方法名(首字母需要大写,例如属性为list,则传List)
     * @param <T>
     * @return 树形list
     * @throws NoSuchMethodException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    public static <T> List<T> listToTree(List<T> list, String idName, String parentIdName, String childrenName) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        List<T> result = new ArrayList<>();//保存最终数据
        Map<String,T> hash = new HashMap();//保存所有数据，用于对比
        for (T t : list){
            String id = reflect(t, GET + idName).toString();
            hash.put(id, t);//key为id
        }
        for (T t : list) {
            String pid = reflect(t, GET + parentIdName).toString();
            T hasPar = hash.get(pid);
            if(hasPar!=null){//父节点存在，添加当前节点到父节点的child
                List<T> children = (List) reflect(hasPar,GET + childrenName);
                //如果封装子对象的list为空，则创建
                if (children == null) {
                    hasPar.getClass().getMethod(SET + childrenName, List.class).invoke(hasPar, new ArrayList<>());
                }
                //重新获取子对象的list
                List children2 = (List) reflect(hasPar, GET + childrenName);
                children2.add(t);//添加当前对象
            }else{//父节点不存在
                result.add(t);
            }
        }
        return result;
    }

    /**
     * list集合转tree树（使用递归，效率问题，数据量大的情况下，不建议使用）
     * @param list         需要转化树形的list
     * @param idName       实体类中id的属性名(首字母需要大写,例如属性为id,则传Id)
     * @param parentIdName 实体类中父id的属性名(首字母需要大写,例如属性为parentId,则传ParentId)
     * @param childrenName 实体类中封装树形的子list方法名(首字母需要大写,例如属性为list,则传List)
     * @return 树形list
     */
    public static <T> List<T> listToTree2(List<T> list, String idName, String parentIdName, String childrenName) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        List<T> result = new ArrayList<>();
        //遍历封装pid=0的
        for (T t : list) {
            //根据反射，获取父id的值
            String pId = reflect(t,GET + parentIdName).toString();
            //如果pd=0，即是首层
            if (ROOT_ID.equals(pId)) {
                //递归查询并封装子对象
                result.add(findChildren(t, list, idName, parentIdName, childrenName));
            }
        }
        return result;
    }

    /**
     * 递归查找子节点
     * @param idName       实体类中id的属性名(首字母需要大写)
     * @param parentIdName 实体类中父id的属性名(首字母需要大写)
     * @param bean
     * @param beans
     * @return
     */
    public static <T> T findChildren(T bean, List<T> beans, String idName, String parentIdName, String childrenName) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        //获取bean的id, bean.getId()
        String id = reflect(bean,GET + idName).toString();
        //获取bean用来封装子对象的list, bean.getList()
        List<T> children = (List) reflect(bean,GET + childrenName);
        //递归遍历
        for (T it : beans) {
            //根据反射，获取it的pId的值 it.getParentId()
            String parentId = it.getClass().getMethod(GET + parentIdName).invoke(it).toString();
            //如果是其子对象
            if (id.equals(parentId)) {
                //如果封装子对象的list为空，则创建
                if (children == null) {
                    bean.getClass().getMethod(SET + childrenName, List.class).invoke(bean, new ArrayList<>());
                }
                //重新获取子对象的list
                children = (List) reflect(bean,GET + childrenName);
                //继续递归遍历
                children.add(findChildren(it, beans, idName, parentIdName, childrenName));
            }
        }
        return bean;
    }

    /**
     * 根据反射获取属性值
     * @param t          对象
     * @param methodName 方法名
     * @param <T>        对象类
     * @return 执行方法后的返回值
     */
    public static <T> Object reflect(T t, String methodName) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        return t.getClass().getMethod(methodName).invoke(t);
    }

    /**
     * json数组转tree树（直接操作json数组）
     * @param arr 需要转化的JSONArray
     * @param idName    主键id标识
     * @param parentIdName   父id标识
     * @param childrenName 子节点键值
     * @return
     */
    public static JSONArray jsonArrayToTree(JSONArray arr, String idName, String parentIdName, String childrenName){
        JSONArray result = new JSONArray();//保存最终得到的数据
        Map hash = new HashMap();
        for(int i=0;i<arr.size();i++){//将数组转为Object的形式
            JSONObject json = (JSONObject) arr.get(i);
            hash.put(json.getString(idName), json);//key为数组中的id
        }
        //遍历结果集
        for(int j=0;j<arr.size();j++){
            JSONObject aVal = (JSONObject) arr.get(j);//获取当前节点
            JSONObject hashPar = (JSONObject) hash.get(aVal.getString(parentIdName));//获取当前节点的父节点
            if(hashPar!=null){//父节点存在，添加当前节点到父节点的child
                if(hashPar.get(childrenName)!=null){//父节点的child属性存在
                    JSONArray child = (JSONArray) hashPar.get(childrenName);
                    child.add(aVal);
                    hashPar.put(childrenName, child);
                }else{//父节点的child属性不存在
                    JSONArray child = new JSONArray();
                    child.add(aVal);
                    hashPar.put(childrenName, child);
                }
            }else{//父节点不存在
                result.add(aVal);
            }
        }
        return result;
    }

}