平级数据处理成树数据工具类

最新推荐文章于 2023-01-17 22:30:00 发布
最新推荐文章于 2023-01-17 22:30:00 发布
阅读量377 收藏
点赞数
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuiyuetianwy/article/details/122178875
版权

此工具类支持如下功能点:

1、平级数据递归处理成树数据

2、支持设定子级集合名称

3、支持设定多个排序字段

4、支持返回某个节点下的子级集合树数据

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;

import java.util.Comparator;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * @author ：yangwang
 * @description：平级数据处理成树数据工具类
 * @email 1187493980@qq.com
 *        shuiyuetianwy@gmaill.com
 * @date ：2021/12/27 16:02
 */
public class HandleToTreeUtils {

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param dataArr 原始数据
     *       必含字段:id-主键,parentId-父级id
     * @return JSONArray 结果集
     */
    public static JSONArray handleToTree(JSONArray dataArr){
        JSONArray resultJson = new JSONArray();
        recursionHandleToTree(resultJson,dataArr,null,null);
        return resultJson;
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param dataArr 原始数据
     *       必含字段:id-主键,parentId-父级id
     * @param curId 当前节点id
     * @return JSONArray 结果集
     */
    public static JSONArray handleToTree(JSONArray dataArr,String curId){
        JSONArray resultJson = new JSONArray();
        recursionHandleToTree(resultJson,dataArr,curId,null);
        return resultJson;
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param dataArr 原始数据
     *       必含字段:id-主键,parentId-父级id
     * @param sortObjs 排序对象
     *      [{"name":"","isAsc":false},{"name":""}]
     *      name 排序字段名称
     *      isAsc true-升序(默认),false-倒叙
     * @return JSONArray 结果集
     *
     */
    public static JSONArray handleToTree(JSONArray dataArr,Object... sortObjs){
        JSONArray resultJson = new JSONArray();
        recursionHandleToTree(resultJson,dataArr,null,null,sortObjs);
        return resultJson;
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param dataArr 原始数据
     *       必含字段:id-主键,parentId-父级id
     * @param curId 当前节点id
     * @param childsName 子级集合名称(默认-childs)
     * @return JSONArray 结果集
     */
    public static JSONArray handleToTree(JSONArray dataArr,String curId,String childsName){
        JSONArray resultJson = new JSONArray();
        recursionHandleToTree(resultJson,dataArr,curId,childsName);
        return resultJson;
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param dataArr 原始数据
     *       必含字段:id-主键,parentId-父级id
     * @param curId 当前节点id
     * @param sortObjs 排序对象
     *       [{"name":"","isAsc":false},{"name":""}]
     *       name 排序字段名称
     *       isAsc true-升序(默认),false-倒叙
     * @return JSONArray 结果集
     */
    public static JSONArray handleToTree(JSONArray dataArr,String curId,Object... sortObjs){
        JSONArray resultJson = new JSONArray();
        recursionHandleToTree(resultJson,dataArr,curId,null,sortObjs);
        return resultJson;
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param dataArr 原始数据
     *       必含字段:id-主键,parentId-父级id
     * @param curId 当前节点id
     * @param childsName 子级集合名称(默认-childs)
     * @param sortObjs 排序对象
     *      [{"name":"","isAsc":false},{"name":""}]
     *      name 排序字段名称
     *      isAsc true-升序(默认),false-倒叙
     * @return JSONArray 结果集
     */
    public static JSONArray handleToTree(JSONArray dataArr,String curId,String childsName,Object... sortObjs){
        JSONArray resultJson = new JSONArray();
        recursionHandleToTree(resultJson,dataArr,curId,childsName,sortObjs);
        return resultJson;
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param resultJson 结果集
     * @param dataArr 原始数据
     *       必含字段:id-主键,parentId-父级id
     */
    public static void handleToTree(JSONArray resultJson, JSONArray dataArr){
        recursionHandleToTree(resultJson,dataArr,null,null);
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param resultJson 结果集
     * @param dataArr 原始数据
     *        必含字段:id-主键,parentId-父级id
     * @param curId 当前节点id
     */
    public static void handleToTree(JSONArray resultJson, JSONArray dataArr,String curId){
        recursionHandleToTree(resultJson,dataArr,curId,null);
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param resultJson 结果集
     * @param dataArr 原始数据
     *        必含字段:id-主键,parentId-父级id
     * @param sortObjs 排序对象
     *      [{"name":"","isAsc":false},{"name":""}]
     *      name 排序字段名称
     *      isAsc true-升序(默认),false-倒叙
     */
    public static void handleToTree(JSONArray resultJson, JSONArray dataArr,Object... sortObjs){
        recursionHandleToTree(resultJson,dataArr,null,null,sortObjs);
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param resultJson 结果集
     * @param dataArr 原始数据
     *        必含字段:id-主键,parentId-父级id
     * @param curId 当前节点id
     * @param childsName 子级集合名称(默认-childs)
     */
    public static void handleToTree(JSONArray resultJson, JSONArray dataArr,String curId,String childsName){
        recursionHandleToTree(resultJson,dataArr,curId,childsName);
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param resultJson 结果集
     * @param dataArr 原始数据
     *        必含字段:id-主键,parentId-父级id
     * @param curId 当前节点id
     * @param sortObjs 排序对象
     *      [{"name":"","isAsc":false},{"name":""}]
     *      name 排序字段名称
     *      isAsc true-升序(默认),false-倒叙
     */
    public static void handleToTree(JSONArray resultJson, JSONArray dataArr,String curId,Object... sortObjs){
        recursionHandleToTree(resultJson,dataArr,curId,null,sortObjs);
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param resultJson 结果集
     * @param dataArr 原始数据
     *        必含字段:id-主键,parentId-父级id
     * @param curId 当前节点id
     * @param childsName 子级集合名称(默认-childs)
     * @param sortObjs 排序对象
     *      [{"name":"","isAsc":false},{"name":""}]
     *      name 排序字段名称
     *      isAsc true-升序(默认),false-倒叙
     */
    public static void handleToTree(JSONArray resultJson, JSONArray dataArr,String curId,String childsName,Object... sortObjs){
        recursionHandleToTree(resultJson,dataArr,curId,childsName,sortObjs);
    }

    /**
     * @description: 递归处理为树结构
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param resultJson 结果集
     * @param dataArr 原始数据
     *       必含字段:id-主键,parentId-父级id
     * @param curId 节点id
     * @param childsName 子级集合名称(默认-childs)
     * @param sortObjs 排序对象
     *      [{"name":"","isAsc":false},{"name":""}]
     *      name 排序字段名称
     *      isAsc true-升序(默认),false-倒叙
     */
    private static void recursionHandleToTree(JSONArray resultJson, JSONArray dataArr, String curId, String childsName,Object... sortObjs){
        if((null!=dataArr)&&(0<dataArr.size())){
            //按orgId筛选
            if(StringUtils.isNotBlank(curId)){
                //获取当前对象下子级
                JSONArray childJson = dataArr.stream().filter(d -> {
                    if(null!=d){
                        JSONObject dObj = (JSONObject) d;
                        if((null!=dObj)&&(dObj.containsKey("id"))&&(dObj.containsKey("parentId"))&&(StringUtils.equals(dObj.getString("parentId"),curId))){
                            return true;
                        }
                    }
                    return false;
                })
                .sorted(new DataSortComparator(sortObjs))
                .collect(Collectors.toCollection(JSONArray::new));
                if((null!=childJson)&&(0<childJson.size())){
                    JSONObject dataObj =null;
                    JSONArray levelTwoJson =null;
                    for(Object data:childJson){
                        if(null != data){
                            dataObj = (JSONObject) data;
                            if((null!=dataObj)&&(dataObj.containsKey("id"))&&(StringUtils.isNotBlank(dataObj.getString("id")))){
                                levelTwoJson = new JSONArray();
                                //递归处理子级为树结构
                                recursionHandleToTree(levelTwoJson,dataArr,dataObj.getString("id"),childsName,sortObjs);
                                if((null!=levelTwoJson)&&(0<levelTwoJson.size())){
                                    //去重排序
                                    levelTwoJson = levelTwoJson.stream().distinct().filter(d -> {
                                        if(null!=d){
                                            JSONObject dObj = (JSONObject) d;
                                            if((null!=dObj)&&(dObj.containsKey("id"))&&(StringUtils.isNotBlank(dObj.getString("id")))){
                                                return true;
                                            }
                                        }
                                        return false;
                                    })
                                    .sorted(new DataSortComparator(sortObjs))
                                    .collect(Collectors.toCollection(JSONArray::new));
                                    dataObj.put(((StringUtils.isNotBlank(childsName))?childsName:"childs"),levelTwoJson);
                                }else{
                                    dataObj.put(((StringUtils.isNotBlank(childsName))?childsName:"childs"),new JSONArray());
                                }
                                //保存当前对象到结果集
                                resultJson.add(dataObj);
                            }
                        }
                    }
                }
            }else{
                JSONObject dataObj =null;
                JSONObject topObj =null;
                Optional<Object> existOpt =null;
                JSONArray childJson =null;
                for(Object data:dataArr){
                    if(null != data){
                        dataObj = (JSONObject) data;
                        if((null!=dataObj)&&(dataObj.containsKey("id"))&&(StringUtils.isNotBlank(dataObj.getString("id")))){
                            topObj = new JSONObject();
                            if((dataObj.containsKey("parentId"))&&(StringUtils.isNotBlank(dataObj.getString("parentId")))){
                                //检索顶级组织节点
                                topObj = findTopOrgNode(dataArr,dataObj.getString("parentId"));
                            }
                            if((null==topObj)||(!topObj.containsKey("id"))||    (StringUtils.isBlank(topObj.getString("id")))){
                                topObj = dataObj;
                            }
                            if(null!=topObj){
                                //判断是否存在
                                Boolean existFlag = false;
                                if((null!=resultJson)&&(0<resultJson.size())){
                                    String topOrgId = topObj.getString("id");
                                    existOpt = resultJson.stream().filter(s -> {
                                        if(null!=s){
                                            JSONObject dObj = (JSONObject) s;
                                            if((null!=dObj)&&(dObj.containsKey("id"))&&(StringUtils.isNotBlank(dObj.getString("id")))&&(StringUtils.equals(dObj.getString("id"),topOrgId))){
                                                return true;
                                            }
                                        }
                                        return false;
                                    }).findAny();
                                    existFlag = existOpt.isPresent();
                                }
                                if(! existFlag){
                                    childJson = new JSONArray();
                                    //递归处理子级为树结构
                                    recursionHandleToTree(childJson,dataArr,topObj.getString("id"),childsName,sortObjs);
                                    topObj.put(((StringUtils.isNotBlank(childsName))?childsName:"childs"),childJson);
                                    resultJson.add(topObj);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * @description: 检索顶级节点
     * @author: yangwang
     * @date: 2021/12/27 16:07
     * @param dataArr 原始数据
     * @param curId 当前节点id
     * @return JSONObject
     */
    private static JSONObject findTopOrgNode(JSONArray dataArr,String curId){
        if(StringUtils.isNotBlank(curId)){
            Optional<Object> parentOpt = dataArr.stream().distinct().filter(d -> {
                if(null!=d){
                    JSONObject dObj = (JSONObject) d;
                    if((null!=dObj)&&(dObj.containsKey("id"))&&(StringUtils.isNotBlank(dObj.getString("id")))&&(StringUtils.equals(dObj.getString("id"),curId))){
                        return true;
                    }
                }
                return false;
            }).findAny();
            if(parentOpt.isPresent()){
                JSONObject dataObj = (JSONObject) parentOpt.get();
                if((null!=dataObj)&&(dataObj.containsKey("id"))&&(StringUtils.isNotBlank(dataObj.getString("id")))){
                    if((dataObj.containsKey("parentId"))&&(StringUtils.isNotBlank(dataObj.getString("parentId")))){
                        JSONObject parentObj = findTopOrgNode(dataArr,dataObj.getString("parentId"));
                        return (null!=parentObj)?parentObj:dataObj;
                    }
                    return dataObj;
                }
            }
        }

        return null;
    }

    /**
     * @description: 数据排序比较器
     *      sortObjs 排序对象
     *      [{"name":"","isAsc":false},{"name":""}]
     *      name 排序字段名称
     *      isAsc true-升序(默认),false-倒叙
     * @author: yangwang
     * @date: 2021/12/27 17:27
     */
    public static class DataSortComparator implements Comparator<Object>{
        /*排序对象*/
        private Object[] sortObjs;

        public DataSortComparator(Object[] sortObjs){
            super();
            this.sortObjs = sortObjs;
        }

        @Override
        public int compare(Object before, Object after) {
            int compareInt = 0;
            if((null!=sortObjs)&&(0 < sortObjs.length)&&(null!=before)&&(null!=after)){
                JSONObject sortObj =null;
                JSONObject objOne = null;
                JSONObject objTwo = null;
                for(Object obj:sortObjs){
                    if(null!=obj){
                        sortObj = (JSONObject) obj;
                        if((null!=sortObj)&&(sortObj.containsKey("name"))){
                            objOne = ((sortObj.containsKey("isAsc"))&&(!sortObj.getBoolean("isAsc")))?(JSONObject) after:(JSONObject) before;
                            objTwo = ((sortObj.containsKey("isAsc"))&&(!sortObj.getBoolean("isAsc")))?(JSONObject) before:(JSONObject) after;
                            if((objOne.containsKey(sortObj.getString("name")))&&(null != objOne.get(sortObj.getString("name")))&&(objTwo.containsKey(sortObj.getString("name")))&&(null != objTwo.get(sortObj.getString("name")))){
                                try {
                                    compareInt = (new Double(objOne.getDoubleValue(sortObj.getString("name")))).compareTo(new Double(objTwo.getDoubleValue(sortObj.getString("name"))));
                                }catch (Exception e){
                                    compareInt = (objOne.getString(sortObj.getString("name"))).compareTo(objTwo.getString(sortObj.getString("name")));
                                }
                                if(0 == compareInt){
                                    continue;
                                }else{
                                    return compareInt;
                                }
                            }
                        }
                    }
                }
            }
            return compareInt;
        }
    }

}
风暴幽居
关注
专栏目录
java返回数据给前端_JAVA后台转换成树结构数据返回给前端的实现方法
weixin_33957382的博客
02-16 666
我们会经常用到树形，那么树形结构的数据是在前端做还是在后台做呢？我自己用过前端的ztree,selectTree等这些属于前端的组件，后台只需要把一个表的所有数据返回给前段就可以，前端可以通过id,pid来把层级结构划分，要是我们前端需要后台直接返回树结构数据怎么办，那么接下来我给大家介绍一下我写过的例子。我们先看一张图了解一下树结构：我这里随便找一张图了解一下即可接下来我们看一下数据，主要包括i...
Java 将有父子关系的数据转换成树形结构数据
01-07
一、数据库父子结构数据设计     大部分采用 parentId的形式来存储父id，并且只存储父id，祖父Id不存储。也可以添加存储层级级别或者层级关系等字段。 CREATE TABLE `t_resource` ( `id` varchar(255) NOT NULL COMMENT '主键', `parent_id` varchar(255) DEFAULT NULL COMMENT '父ID', `name` varchar(255) DEFAULT NULL COMMENT '名称', `url` varchar(255) DEFAULT NULL COMMENT '
平级数据转化树状数据
GW05431的博客
01-17 297
评级数据转换树形数据三种方法
将平级数据转换成树状结构数据
qq_53961292的博客
11-08 302
将平级数据转换成树状结构数据
平级数组转化为树形数组（递归方式）
lizhichengwei的博客
01-05 320
项目中，我们会遇到很多做树形数据的时候，那么怎么把平铺数组转化为属性数组呢？
Java 数据处理工具类
灵魂在奔跑
03-05 974
package com.lyis.commons.util; import java.math.BigDecimal; import java.util.regex.Pattern; /** * 数字处理工具类 * * @author LeiRenzheng * @version Monday October 25th, 2010 */ public class NumberUtils { /** * 判断当前值是否为整数 * * @param valu
list转树状结构通用工具类
最新发布
03-21
通过以上设计，我们就可以创建一个通用的工具类，能够处理任意具有父子关系的list数据，将其转换为树状结构，且支持存在多个顶级节点的情况。这个工具类在实际开发中具有很高的实用性，可应用于多种场景，例如数据...
java转树形结构工具类详解
09-07
在Java编程中，将数据结构从...总结起来，这个Java转树形结构的工具类提供了一种高效且灵活的方式来处理具有层级关系的数据，使得我们能够轻松地将列表数据转换为树形结构，便于在GUI界面或者数据操作中展现和管理。
TreeUtil工具类
11-25
在Java编程中，TreeUtil工具类是一个非常实用的辅助类，尤其在处理树形数据结构时。树形结构广泛应用于各种场景，如文件系统、组织结构、菜单系统等。TreeUtil通常包含一系列静态方法，方便开发者对树节点进行操作，...
22考研王道数据结构知识点ppt总结.zip
12-13
数据结构是组织、存储和处理数据的方式，包括线性结构（如数组、链表）、树形结构、图形结构以及特殊结构（如堆、栈、队列）。理解这些基本概念有助于我们设计高效的算法来解决实际问题。 接着，6.1_1_图的基本概念...
7、数字处理工具类
weixin_53330986的博客
10-16 125
7、数字处理工具类 BigInteger类：可以超过integer范围内的数据进行运算 构造方法：public BigInteger (String val) 常用方法： public BigInteger add(BigIntege val) //加 public BigInteger subtract(BigIntege val) //减 public BigInteger multiply(BigIntege val) //乘 public BigInteger divide(B
将平整数据转化为树形数据
qq_43620719的博客
12-03 305
构造树型结构数据函数 function handleTree(data, id, parentId, children, rootId) { id = id || 'id' parentId = parentId || 'parentId' children = children || 'children' rootId = rootId || 0 //对源数据深度克隆 const cloneData = JSON.parse(JSON.stringify(data))
Java 驼峰与下划线的属性名互相转换
Hason的专栏
09-12 7545
public class StringUtil { /** * 转换为下划线 * * @param camelCaseName * @return */ public static String underscoreName(String camelCaseName) { StringBuilder result = new StringBuilder(); i
java将数据整合成tree所需要的格式
福尔摩杰的博客
07-29 366
在项目开发中, 经常会使用到树状结构, 树状结构基本就是有父子关系的, 通过后台的逻辑, 处理成 {id: ‘’, title: ‘’, children: []} 这样放到前台使用树的一些相关js就可以直接展示了, 前台无需在进行复杂的操作. 下面就是java后台的相关代码. 可以直接使用, 如果前台需要的参数不符合, 修改一下即可: public Object treeList(String id) { List<Map> clazzList = new ArrayList
平级数据处理为层级数据&数组对象相同项合并。
Ricale的博客
06-30 160
平级数据处理为层级数据 数组对象相同项合并
将数据库读取的平级数据转换成父子孙结构
xueshuQ的博客
09-15 1056
前几天写接口，需求是从保存系统中所有模块、页面、操作的数据库表中读取数据，然后形成父子孙结构，当时为了不多次读取数据库，想了一种方法，当时费了一下午才把接口写出来，不管是不是好的方法，先写出来mark一下。 1、需求就是加载数据库中所有的模块，页面，操作，并按照三级结构展示（若数据库中真的存在没有模块的页面，或者没有页面的操作，这些数据不加载出来） 2、实现过程就是： 首先，从数据库
把平级数据变成树形数据
weixin_34279579的博客
07-28 751
为了记住这个方法：转化数据 [ {element:'图片',id:'1',pid:'0'},//count=1 {element:'大图片',id:'2',pid:'1'}, {element:'png',id:'3',pid:'2'}, {element:'jpeg',id:'4',pid:'2'}, ...
JavaScript将数据处理成树形结构
weixin_43954835的博客
05-18 1821
第一个方法是使用递归，可以处理多层嵌套。（react的value值和key值不一样是会报错的，而且key值要唯一，如果这组数据需要带有搜索功能的话是要设置treeNodeFilterProp来指定根据哪个字段来搜索的）。如果传进来的数据保证是有字段的可以省略判断的步骤，递归这个方法也可以结合第二个方法让代码看起来更简洁。 function toTree(data) { for (let i = 0; i < data.length; i++) { data[i].value =
分页工具类，大量数据分批处理工具类
菜鸟在进步
08-30 479
package com.itmayiedu.day01; import java.util.ArrayList; import java.util.List; public class ListUtils { static public List
qt sql数据封装成树
05-24
要将 Qt SQL 数据封装成树，你需要完成以下步骤： 1. 从数据库中检索数据，将其存储在一个 Qt SQL 模型中。可以使用 QSqlQueryModel 或 QSqlTableModel 来完成这个步骤。 2. 为树节点创建一个数据结构。可以使用 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值