Java实现树数据Tree与List互转并逐级汇总节点的值(支持树节点多列统计）

最新推荐文章于 2024-07-03 19:22:05 发布
最新推荐文章于 2024-07-03 19:22:05 发布
阅读量7.8k 收藏 24
点赞数 3
分类专栏： Java 文章标签： Java Tree ListTree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boonya/article/details/92840509
版权

主要需求：a.实现树Tree与List互转   b.Tree实现多列统计数据汇总。前度采用MiniUI。

逐级汇总数据：找到最小节点，然后回溯其所有父节点，注意值的重复计算问题。

构造一棵树的基本节点：

package com.example.demo.tree;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: TreeNode
 * @Description: TODO(树的节点对象)
 * @author: pengjunlin
 * @motto: 学习需要毅力，那就秀毅力
 * @date 2019-06-18 23:35
 */
public class TreeNode {

    /**
     * 节点ID
     */
    private long id;
    /**
     * 显示名称
     */
    private String label;
    /**
     * 当前节点的唯一值
     */
    private double value;
    /**
     * 当前节点的多个值的表达方式
     */
    private double[] multiValues=new double[]{};
    /**
     * 汇总单个节点的多个值
     */
    private List<Double> values=new ArrayList<Double>();
    /**
     * 当前节点所有子节点的值集合
     */
    private List<double []> childrenMultiValues=new ArrayList<double []>();
    /**
     * 父节点ID
     */
    private long pid;
    /**
     * 子节点集合对象
     */
    private List<TreeNode> children=new ArrayList<TreeNode>();
    /**
     * 是否计算本身
     */
    private boolean addSelf=false;

    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 double getValue() {
        return value;
    }

    public void setValue(double value) {
        this.value = value;
    }

    public double[] getMultiValues() {
        return multiValues;
    }

    public void setMultiValues(double[] multiValues) {
        this.multiValues = multiValues;
    }

    public List<Double> getValues() {
        return values;
    }

    public void setValues(List<Double> values) {
        this.values = values;
    }

    public List<double[]> getChildrenMultiValues() {
        return childrenMultiValues;
    }

    public void setChildrenMultiValues(List<double[]> childrenMultiValues) {
        this.childrenMultiValues = childrenMultiValues;
    }

    public long getPid() {
        return pid;
    }

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

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

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

    public boolean isAddSelf() {
        return addSelf;
    }

    public void setAddSelf(boolean addSelf) {
        this.addSelf = addSelf;
    }
}

构造树管理工具：

package com.example.demo.tree;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * @ClassName: TreeManager
 * @Description: TODO(树结构数据管理-实践验证)
 * @author: pengjunlin
 * @motto: 学习需要毅力，那就秀毅力
 * @date 2019-06-18 23:47
 */
public class TreeManager {

    /**
     * 将List转成tree结构数据
     * @param list
     * @param rootId 默认顶级节点ID
     * @return
     */
    public static List<TreeNode> listToTree(List<TreeNode> list,long rootId){
        List<TreeNode> tree=new ArrayList<TreeNode>();
        Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
        // 将所有的数据，以键值对的形式装入map中
        for (TreeNode node : list) {
            // 去除冗余的子节点
            node.setChildren(new ArrayList<TreeNode>());
            map.put(node.getId(), node);
        }
        for (TreeNode node : list) {
            // 如果id是父级的话就放入tree中
            if (node.getId() == rootId) {
                tree.add(node);
            } else {
                // 子级通过父id获取到父级的类型
                TreeNode parent = map.get(node.getPid());
                // 父级获得子级，再将子级放到对应的父级中
                if(parent!=null){
                    parent.getChildren().add(node);
                }
            }
        }
        return tree;
    }

    /**
     * 将tree结构数据转成List结构
     * @param list
     * @return
     */
    public static void treeToList(TreeNode node,List<TreeNode> list){
        if(list==null){
            list=new ArrayList<TreeNode>();
        }
        //设置当前节点的必要数据
        TreeNode nodeValue=new TreeNode();
        nodeValue.setId(node.getId());
        nodeValue.setLabel(node.getLabel());
        nodeValue.setValue(node.getValue());
        nodeValue.setMultiValues(node.getMultiValues());
        nodeValue.setChildrenMultiValues(node.getChildrenMultiValues());
        nodeValue.setPid(node.getPid());
        nodeValue.setChildren(new ArrayList<TreeNode>());
        list.add(nodeValue);
        //遍历递归子节点
        if(node.getChildren().size()>0){
            for (int i = 0; i < node.getChildren().size(); i++) {
                TreeNode node_= node.getChildren().get(i);
                treeToList(node_,list);
            }
        }
    }

    /**
     * 转换数据格式并设置对应节点的值汇总到根节点
     * @param list
     * @param rootId
     * @return
     */
    public static List<TreeNode> listToTreeWithSingleValue(List<TreeNode> list,long rootId){
        Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
        // 将所有的数据，以键值对的形式装入map中
        for (TreeNode node : list) {
            // 去除冗余的子节点
            node.setChildren(new ArrayList<TreeNode>());
            map.put(node.getId(), node);
        }
        List<TreeNode> tree=listToTree(list,rootId);
       /* // 存储最小子节点ID
        Map<Long,Object> leafList=new  HashMap<Long,Object>();
        findMinNodes(tree.get(0),leafList,0);
        // 设置每个节点的值
        for (Long id_: leafList.keySet()) {
            // 内部递归树的父节点层级多于2会存在重复计算
            setParentNodeValue(map,id_);
        }*/

        // 存储最小子节点ID
        Map<Long,Object> leaf=new  HashMap<Long,Object>();
        findMinNodes(tree.get(0),leaf);
        // 逐级设置父节点的值
        setValuesToParentNode(leaf, map);

        // 汇总所有节点的值
        double total=0;
        for (TreeNode node:map.values() ) {
            total=0;
            for (double value: node.getValues() ) {
                total+=value;
            }
            node.setValue(total);
            map.put(node.getId(),node);
        }
        List<TreeNode>  result=new ArrayList<TreeNode>();
        for (TreeNode node:map.values()) {
            result.add(node);
        }
        return listToTree(result,rootId);
    }

    /**
     * 转换数据格式并设置对应节点的值汇总到根节点
     * @param tree
     * @return
     */
    public static  List<TreeNode>   treeToListWithSingleValue(TreeNode tree){
        List<TreeNode> list=new ArrayList<TreeNode>();
        // 获取到List
        treeToList(tree,list);
        Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
        // 将所有的数据，以键值对的形式装入map中
        for (TreeNode node : list) {
            // 去除冗余的子节点
            node.setChildren(new ArrayList<TreeNode>());
            map.put(node.getId(), node);
        }
       /* // 存储最小子节点ID
        Map<Long,Object> leafList=new  HashMap<Long,Object>();
        findMinNodes(tree,leafList,0);
        // 设置每个节点的值
        for (Long id_: leafList.keySet()) {
            // 内部递归树的父节点层级多于2会存在重复计算
            setParentNodeValue(map,id_);
        }*/

        // 存储最小子节点ID
        Map<Long,Object> leaf=new  HashMap<Long,Object>();
        findMinNodes(tree,leaf);
        // 逐级设置父节点的值
        setValuesToParentNode(leaf, map);

        // 汇总所有节点的值
        double total=0;
        for (TreeNode node:map.values() ) {
            total=0;
            for (double value: node.getValues() ) {
                total+=value;
            }
            node.setValue(total);
            map.put(node.getId(),node);
        }
        List<TreeNode>  result=new ArrayList<TreeNode>();
        for (TreeNode node:map.values()) {
            result.add(node);
        }
        return result;
    }

    /**
     * 转换数据格式并设置对应节点的值汇总到根节点
     * @param list
     * @param rootId
     * @param columns
     * @return
     */
    public static List<TreeNode> listToTreeWithMultiValues(List<TreeNode> list,long rootId,int columns){
        Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
        // 将所有的数据，以键值对的形式装入map中
        for (TreeNode node : list) {
            // 去除冗余的子节点
            node.setChildren(new ArrayList<TreeNode>());
            map.put(node.getId(), node);
        }
        List<TreeNode> tree=listToTree(list,rootId);

       /* // 存储最小子节点ID
        Map<Long,Object> leafList=new  HashMap<Long,Object>();
        findMinNodes(tree.get(0),leafList,0);
        // 设置每个节点的值
        for (Long id_: leafList.keySet()) {
            // 内部递归树的父节点层级多于2会存在重复计算
            setParentNodeMultiValues(map,id_);
        }*/

        // 存储最小子节点ID
        Map<Long,Object> leaf=new  HashMap<Long,Object>();
        findMinNodes(tree.get(0),leaf);
        // 逐级追加父节点的值
        setMultiValuesToParentNode(leaf, map);

        // 汇总所有节点的值
        double [] valueColumns=null;
        for (TreeNode node:map.values() ) {
            valueColumns=new double[columns];
            for (double [] values: node.getChildrenMultiValues() ) {
                for (int i = 0,j=values.length; i < j; i++) {
                    valueColumns[i]+=values[i];
                }
            }
            node.setMultiValues(valueColumns);
            map.put(node.getId(),node);
        }
        List<TreeNode>  result=new ArrayList<TreeNode>();
        for (TreeNode node:map.values()) {
            result.add(node);
        }
        return listToTree(result,rootId);
    }

    /**
     * 转换数据格式并设置对应节点的值汇总到根节点
     * @param tree
     * @param columns
     * @return
     */
    public static  List<TreeNode>  treeToListWithMultiValues(TreeNode tree,int columns){
        List<TreeNode> list=new ArrayList<TreeNode>();
        // 获取到List
        treeToList(tree,list);
        Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
        // 将所有的数据，以键值对的形式装入map中
        for (TreeNode node : list) {
            // 去除冗余的子节点
            node.setChildren(new ArrayList<TreeNode>());
            map.put(node.getId(), node);
        }
        /*
        // 存储最小子节点ID
        Map<Long,Object> leafList=new  HashMap<Long,Object>();
        findMinNodes(tree,leafList,0);
        // 设置每个节点的值
        for (Long id_: leafList.keySet()) {
             // 内部递归树的父节点层级多于2会存在重复计算
            setParentNodeMultiValues(map,id_);
        }*/

        // 存储最小子节点ID
        Map<Long,Object> leaf=new  HashMap<Long,Object>();
        findMinNodes(tree,leaf);
        // 逐级追加父节点的值
        setMultiValuesToParentNode(leaf, map);

        // 汇总所有节点的值
        double [] valueColumns=null;
        for (TreeNode node:map.values() ) {
            valueColumns=new double[columns];
            for (double [] values: node.getChildrenMultiValues() ) {
                for (int i = 0,j=values.length; i < j; i++) {
                    valueColumns[i]+=values[i];
                }
            }
            node.setMultiValues(valueColumns);
            map.put(node.getId(),node);
        }
        List<TreeNode>  result=new ArrayList<TreeNode>();
        for (TreeNode node:map.values()) {
            result.add(node);
        }
        return result;
    }

    /**
     * 逐级追加设置节点的值（单个值）
     * @param leaf
     * @param map
     */
    public static void setValuesToParentNode(Map<Long,Object> leaf,Map<Long, TreeNode> map){
        Map<Long,Object> newLeaf=new  HashMap<Long,Object>();
        // 设置每个节点的值
        for (Long id_: leaf.keySet()) {
            setParentNodeValue(newLeaf,map,id_);
        }
        if(newLeaf.size()>1){
            setValuesToParentNode(newLeaf, map);
        }
    }

    /**
     * 逐级追加设置节点的值（多个值）
     * @param leaf
     * @param map
     */
    public static void setMultiValuesToParentNode( Map<Long,Object> leaf,Map<Long, TreeNode> map){
        Map<Long,Object> newLeaf=new  HashMap<Long,Object>();
        // 设置每个节点的值
        for (Long id_: leaf.keySet()) {
            setParentNodeMultiValues(newLeaf,map,id_);
        }
        if(newLeaf.size()>1){
            setMultiValuesToParentNode(newLeaf, map);
        }
    }

    /**
     * 数学运算
     * @param mathChar
     * @param dest
     * @param newValue
     */
    public static void mathHandle(String mathChar,double dest,double newValue){
        switch (mathChar) {
            case "+":
                dest+=newValue;
                break;
            case "-":
                dest-=newValue;
                break;
            case "*":
                dest*=newValue;
                break;
            case "/":
                dest/=newValue;
                break;
            default:
                break;
        }
    }

    /**
     * 查找最小子叶节点（没有子节点的节点）
     * @param node
     * @param leafList
     */
    private static void findMinNodes(TreeNode node,Map<Long,Object> leafList){
        if(node.getChildren().size()>0){
            TreeNode nodeTmp=null;
            for (int i = 0; i < node.getChildren().size(); i++) {
                nodeTmp= node.getChildren().get(i);
                findMinNodes(nodeTmp,leafList);
            }
        }else{
            leafList.put(node.getId(),node.getId());
        }
    }

    /**
     * 根据ID逐级查找父节点并设置值(设置单个值逐级递归)
     * @param map
     * @param id
     */
    private static void setParentNodeValue(Map<Long,Object> newLeaf,Map<Long, TreeNode> map,long id){
        TreeNode node=map.get(id);
        // 设置自身节点的值
        if(!node.isAddSelf()){
            node.setAddSelf(true);
            node.getValues().add(node.getValue());
            // 更新节点数据
            map.put(node.getId(),node);
        }
        TreeNode pNode=map.get(node.getPid());
        if(pNode!=null){
            // 将子节点的值赋给父节点
            pNode.getValues().addAll(node.getValues());
            // 设置自身节点的值
            if(!pNode.isAddSelf()){
                pNode.setAddSelf(true);
                pNode.getValues().add(pNode.getValue());
            }
            // 更新节点数据
            map.put(pNode.getId(),pNode);
            //setParentNodeValue(map,pNode.getId());
            newLeaf.put(pNode.getId(), pNode.getId());
        }
    }

    /**
     * 根据ID逐级查找父节点并设置值(设置多个值逐级递归)
     * @param map
     * @param id
     */
    private static void setParentNodeMultiValues(Map<Long,Object> newLeaf,Map<Long, TreeNode> map,long id){
        TreeNode node=map.get(id);
        // 设置自身节点的值
        if(!node.isAddSelf()){
            node.setAddSelf(true);
            node.getChildrenMultiValues().add(node.getMultiValues());
            // 更新节点数据
            map.put(node.getId(),node);
        }
        TreeNode pNode=map.get(node.getPid());
        if(pNode!=null){
            // 将子节点的值赋给父节点
            pNode.getChildrenMultiValues().addAll(node.getChildrenMultiValues());
            // 设置自身节点的值
            if(!pNode.isAddSelf()){
                pNode.setAddSelf(true);
                pNode.getChildrenMultiValues().add(pNode.getMultiValues());
            }
            // 更新节点数据
            map.put(pNode.getId(),pNode);
            //setParentNodeMultiValues(map,pNode.getId());
            newLeaf.put(pNode.getId(), pNode.getId());
        }
    }

    @SuppressWarnings("unused")
    public static void main(String[] args) {
        TreeNode tree=new TreeNode();
        tree.setId(1);
        tree.setLabel("顶层节点");
        tree.setValue(1);
        tree.setChildrenMultiValues(new ArrayList<double []>());
        tree.setPid(0);

        List<TreeNode> list =new ArrayList<TreeNode>();
        TreeNode node1=new TreeNode();
        node1.setId(2);
        node1.setLabel("子节点1");
        node1.setValue(100);
        node1.setMultiValues(new double[]{5,7,3});
        node1.setChildrenMultiValues(new ArrayList<double []>());
        node1.setPid(1);
        list.add(node1);
        TreeNode node2=new TreeNode();
        node2.setId(3);
        node2.setLabel("子节点2");
        node2.setValue(10);
        node2.setMultiValues(new double[]{2,5,8});
        node2.setChildrenMultiValues(new ArrayList<double []>());
        node2.setPid(1);
        list.add(node2);

        tree.setChildren(list);

        List<TreeNode> destList=new ArrayList<TreeNode>();
        TreeManager.treeToList(tree,destList);
        System.out.println("tree转list完成");

        List<TreeNode> treeList=TreeManager.listToTree(destList,1);

        System.out.println("List转tree完成");

        /*******************注意单个值计算结果会影响多个值计算结果**************/

        List<TreeNode> treeListSingleValue=TreeManager.listToTreeWithSingleValue(destList,1);
        System.out.println("List转tree 汇总唯一值value完成");

        List<TreeNode> treeListSingleValue2=TreeManager.treeToListWithSingleValue(tree);
        System.out.println("tree转List 汇总唯一值value完成");

//        List<TreeNode> treeListMultiValues=TreeManager.listToTreeWithMultiValues(destList,1,3);
//        System.out.println("List转tree 汇总多个值values完成");
//
//        List<TreeNode> treeListMultiValues2=TreeManager.treeToListWithMultiValues(tree,3);
//        System.out.println("tree转List 汇总多个值values完成");

    }
}

注：如果数据字段跟工具树的不一致可以使用Map转对象来实现。

Github源码：https://github.com/open-micro-services/springcloud/tree/master/sc-demo-projects/sb-tree

boonya
关注
专栏目录
java树节点逐级汇总.zip
05-08
java无序list数据，可直接汇总，可汇总并转为树形结构数据，可直接作为公用树节点工具类使用，调用汇总类可根据实际情况修改文件内Service方法使用
根据子节点的金额向上汇总所有父节点的金额
07-30
代码 博文链接：https://blueskylan.iteye.com/blog/848447
Java 将树转为List
最新发布
weixin_45817985的博客
07-03 349
Java 将树转为List
java 树型结构转list
轻描时光
05-08 834
/ System.out.println("找到了节点: " + result.value);// System.out.println("未找到节点");// 查找值为5的节点。
Java ：Tree 和 List 集合的相互转化
帅气Dee海绵宝宝
12-13 3113
判断是否存在子集 //判断是否存在子集 private static boolean ifChilds(List<?> list) { boolean flag = false; if (list != null && list.size() != 0) { flag = true; } ...
Java 树节点
长の路的博客
08-11 309
代码】Java 树节点。
java树节点_Java数据结构与算法之树(动力节点java学院整理)
weixin_39566593的博客
02-16 190
为什么使用树：树结合了两种数据结构的有点：一种是有序数组，树在查找数据项的速度和在有序数组中查找一样快；另一种是链表，树在插入数据和删除数据项的速度和链表一样。既然这样，就要好好去学了....(最主要讨论的是二叉树中的二叉搜索树，即一个节点的左子节点关键值小于这个节点，右子节点的关键值大于这个节点)设计前的思考：树——>元素(节点)class Node{public int iData ;p...
java递归查找树的节点_递归树,从叶子节点找到父节点的的各种参数包括路径
weixin_32927133的博客
02-13 3091
这几天有个新需求，无聊的报表，通过各种维度组合成一个树，点击数的节点，组合各种条件去查询数据，由于在树的不同层级，需要向上查找父节点，直到根节点的各种组合条件。所以一个基本的想法是从叶子节点向上递归得到各种条件.给Team的人写了个简单的测试，包括一个树的VO, 条件的类.还有一个主类，测试用的1. 定义 TreeVOpublic class TreeVO {private int pid;pri...
【list转树结构】相关附件
09-12
这段代码中，`TreeNode`类定义了树节点，`list_to_tree`函数实现了从列表到树的转换，`find_parent`函数用于确定元素的父节点。 6. **应用实例**：这种转换在实际开发中有很多应用场景，如构建目录结构、解析XML或...
vue2/3 - 实现手机H5移动端树形无限级组件，在vue网页中使用tree树形菜单或下拉弹框树形节点菜单，支持某项禁用选中、自定义样式、可嵌套在弹框内等（详细示例组件源码，一键复制即可使用）
高级前端工程师
02-20 3723
vue，h5网页，vue手机端，树形菜单，tree，vue树形菜单，树形下拉框，树形下拉选择，树形目录，树形下拉列表，树形插件，树形列表，vue移动端树形控件插件，移动端树控件，vue树形列表（单选，多选）tree树组件，基于Vue的树形选择组件，Vue.js的移动端Tree树形组件，移动端树形选择组件，vue树形组件封装（移动端），vue递归组件树形控件实例代码，Vue2递归组件实现树形菜单，vue3使用递归组件实现树形目录的方法，vue手机h5网站树形控件，vue3之H5实现树形结构，vue实现自定义实
java 树形层级往上汇总属性值
白_的博客
11-27 701
addSelf默认为false，使用addSelf属性来判断是否计算过，没计算过的，递归往下，直至没有子级为参与计算，此时汇总属性值参与汇总到父级。
java 递归list转树，树转list
weixin_43930851的博客
05-04 462
java实践
树形数据逐级向上汇总-java
qq_15674631的博客
05-23 2114
对树状指定结构的某一项，进行求和。上一级该项值，是下级所有该项之和（依次递归）。
java树型数据结构的数据向上汇总
caileigood的博客
05-13 4165
今天有一个需求是一个项目分为好多个模块，最底层的模块由员工填写进度，进度填写后，上级模块自动算出进度，依次上推，页面如图 今天写了一个算法搞出来了，但是感觉有些繁琐，但是还没有想到更好的办法。 思路如下： 1、找到最底层叶子节点 2、从1中的结果中找到pid相同的叶子节点 3、计算结果到父节点中 4、将子节点放入到父节点中 5、将子节点从集合中删除，让其对应的父节点变成最底层子节点 循...
树型结构汇总节点数据
m0_46509482的博客
07-29 635
树型结构汇总节点数据
java 计算父亲节_树形结构统计-递归统计（父亲节点=孩子节点之和）
weixin_29182481的博客
02-26 965
最近做项目遇到树形结构的统计，树的的深度不定，父亲节点=孩子节点之和使用java实现如下：实体bean代码如下：package tt;public class Xmzb {private String id;private String pid;/*** 项目个数*/private Integer xmgs;public String getId() {return id;}public void...
java中ListMap树形结构的集合，进行逐级汇总的抽象
凡江林的博客
09-29 1324
1. map1中累加map2中某个指定key的值（针对数值类型） （1）如果map1中不存在key对应的值，则把map2中对应key的值添加进map1中； （2）否则，map1中存在的值，和map2中存在的值，进行累加。代码如下所示： public static void addMapSameKey(Map<String, Object> map1, Map<String, Object> map2, String key) { if (map1.get(ke
java 遍历树形数据生成List
一路向前
06-21 1738
https://blog.csdn.net/qq_35461948/article/details/112665917 学习了如何生成树形的数据？ 反过来，知道树形数据，如何遍历子集，生成List数据呢？ 要求： 已知当前D环节的id,获取前置环节的id（找出A，B，C环节的id） 当前数据是树形的，比如： [{ "NEXT_TCH_ID": 1009205, "TCH_ID": 1009208, "children": [{ ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值