devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：我家自动化 | 2024-03-01 04:42:11

赞

踩

java 中list向上汇总金额

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

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

构造一棵树的基本节点：

  1. package com.example.demo.tree;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. /**
  7.  * @ClassName: TreeNode
  8.  * @Description: TODO(树的节点对象)
  9.  * @author: pengjunlin
  10.  * @motto: 学习需要毅力，那就秀毅力
  11.  * @date 2019-06-18 23:35
  12.  */
  13. public class TreeNode {
  14.  
  15.     /**
  16.      * 节点ID
  17.      */
  18.     private long id;
  19.     /**
  20.      * 显示名称
  21.      */
  22.     private String label;
  23.     /**
  24.      * 当前节点的唯一值
  25.      */
  26.     private double value;
  27.     /**
  28.      * 当前节点的多个值的表达方式
  29.      */
  30.     private double[] multiValues=new double[]{};
  31.     /**
  32.      * 汇总单个节点的多个值
  33.      */
  34.     private List<Double> values=new ArrayList<Double>();
  35.     /**
  36.      * 当前节点所有子节点的值集合
  37.      */
  38.     private List<double []> childrenMultiValues=new ArrayList<double []>();
  39.     /**
  40.      * 父节点ID
  41.      */
  42.     private long pid;
  43.     /**
  44.      * 子节点集合对象
  45.      */
  46.     private List<TreeNode> children=new ArrayList<TreeNode>();
  47.     /**
  48.      * 是否计算本身
  49.      */
  50.     private boolean addSelf=false;
  51.  
  52.     public long getId() {
  53.         return id;
  54.     }
  55.  
  56.     public void setId(long id) {
  57.         this.id = id;
  58.     }
  59.  
  60.     public String getLabel() {
  61.         return label;
  62.     }
  63.  
  64.     public void setLabel(String label) {
  65.         this.label = label;
  66.     }
  67.  
  68.     public double getValue() {
  69.         return value;
  70.     }
  71.  
  72.     public void setValue(double value) {
  73.         this.value = value;
  74.     }
  75.  
  76.     public double[] getMultiValues() {
  77.         return multiValues;
  78.     }
  79.  
  80.     public void setMultiValues(double[] multiValues) {
  81.         this.multiValues = multiValues;
  82.     }
  83.  
  84.     public List<Double> getValues() {
  85.         return values;
  86.     }
  87.  
  88.     public void setValues(List<Double> values) {
  89.         this.values = values;
  90.     }
  91.  
  92.     public List<double[]> getChildrenMultiValues() {
  93.         return childrenMultiValues;
  94.     }
  95.  
  96.     public void setChildrenMultiValues(List<double[]> childrenMultiValues) {
  97.         this.childrenMultiValues = childrenMultiValues;
  98.     }
  99.  
  100.     public long getPid() {
  101.         return pid;
  102.     }
  103.  
  104.     public void setPid(long pid) {
  105.         this.pid = pid;
  106.     }
  107.  
  108.     public List<TreeNode> getChildren() {
  109.         return children;
  110.     }
  111.  
  112.     public void setChildren(List<TreeNode> children) {
  113.         this.children = children;
  114.     }
  115.  
  116.     public boolean isAddSelf() {
  117.         return addSelf;
  118.     }
  119.  
  120.     public void setAddSelf(boolean addSelf) {
  121.         this.addSelf = addSelf;
  122.     }
  123. }

构造树管理工具：

  1. package com.example.demo.tree;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  7. /**
  8.  * @ClassName: TreeManager
  9.  * @Description: TODO(树结构数据管理-实践验证)
  10.  * @author: pengjunlin
  11.  * @motto: 学习需要毅力，那就秀毅力
  12.  * @date 2019-06-18 23:47
  13.  */
  14. public class TreeManager {
  15.  
  16.     /**
  17.      * 将List转成tree结构数据
  18.      * @param list
  19.      * @param rootId 默认顶级节点ID
  20.      * @return
  21.      */
  22.     public static List<TreeNode> listToTree(List<TreeNode> list,long rootId){
  23.         List<TreeNode> tree=new ArrayList<TreeNode>();
  24.         Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
  25.         // 将所有的数据，以键值对的形式装入map中
  26.         for (TreeNode node : list) {
  27.             // 去除冗余的子节点
  28.             node.setChildren(new ArrayList<TreeNode>());
  29.             map.put(node.getId(), node);
  30.         }
  31.         for (TreeNode node : list) {
  32.             // 如果id是父级的话就放入tree中
  33.             if (node.getId() == rootId) {
  34.                 tree.add(node);
  35.             } else {
  36.                 // 子级通过父id获取到父级的类型
  37.                 TreeNode parent = map.get(node.getPid());
  38.                 // 父级获得子级，再将子级放到对应的父级中
  39.                 if(parent!=null){
  40.                     parent.getChildren().add(node);
  41.                 }
  42.             }
  43.         }
  44.         return tree;
  45.     }
  46.  
  47.     /**
  48.      * 将tree结构数据转成List结构
  49.      * @param list
  50.      * @return
  51.      */
  52.     public static void treeToList(TreeNode node,List<TreeNode> list){
  53.         if(list==null){
  54.             list=new ArrayList<TreeNode>();
  55.         }
  56.         //设置当前节点的必要数据
  57.         TreeNode nodeValue=new TreeNode();
  58.         nodeValue.setId(node.getId());
  59.         nodeValue.setLabel(node.getLabel());
  60.         nodeValue.setValue(node.getValue());
  61.         nodeValue.setMultiValues(node.getMultiValues());
  62.         nodeValue.setChildrenMultiValues(node.getChildrenMultiValues());
  63.         nodeValue.setPid(node.getPid());
  64.         nodeValue.setChildren(new ArrayList<TreeNode>());
  65.         list.add(nodeValue);
  66.         //遍历递归子节点
  67.         if(node.getChildren().size()>0){
  68.             for (int i = 0; i < node.getChildren().size(); i++) {
  69.                 TreeNode node_= node.getChildren().get(i);
  70.                 treeToList(node_,list);
  71.             }
  72.         }
  73.     }
  74.  
  75.     /**
  76.      * 转换数据格式并设置对应节点的值汇总到根节点
  77.      * @param list
  78.      * @param rootId
  79.      * @return
  80.      */
  81.     public static List<TreeNode> listToTreeWithSingleValue(List<TreeNode> list,long rootId){
  82.         Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
  83.         // 将所有的数据，以键值对的形式装入map中
  84.         for (TreeNode node : list) {
  85.             // 去除冗余的子节点
  86.             node.setChildren(new ArrayList<TreeNode>());
  87.             map.put(node.getId(), node);
  88.         }
  89.         List<TreeNode> tree=listToTree(list,rootId);
  90.        /* // 存储最小子节点ID
  91.         Map<Long,Object> leafList=new  HashMap<Long,Object>();
  92.         findMinNodes(tree.get(0),leafList,0);
  93.         // 设置每个节点的值
  94.         for (Long id_: leafList.keySet()) {
  95.             // 内部递归树的父节点层级多于2会存在重复计算
  96.             setParentNodeValue(map,id_);
  97.         }*/
  98.  
  99.         // 存储最小子节点ID
  100.         Map<Long,Object> leaf=new  HashMap<Long,Object>();
  101.         findMinNodes(tree.get(0),leaf);
  102.         // 逐级设置父节点的值
  103.         setValuesToParentNode(leaf, map);
  104.  
  105.         // 汇总所有节点的值
  106.         double total=0;
  107.         for (TreeNode node:map.values() ) {
  108.             total=0;
  109.             for (double value: node.getValues() ) {
  110.                 total+=value;
  111.             }
  112.             node.setValue(total);
  113.             map.put(node.getId(),node);
  114.         }
  115.         List<TreeNode>  result=new ArrayList<TreeNode>();
  116.         for (TreeNode node:map.values()) {
  117.             result.add(node);
  118.         }
  119.         return listToTree(result,rootId);
  120.     }
  121.  
  122.     /**
  123.      * 转换数据格式并设置对应节点的值汇总到根节点
  124.      * @param tree
  125.      * @return
  126.      */
  127.     public static  List<TreeNode>   treeToListWithSingleValue(TreeNode tree){
  128.         List<TreeNode> list=new ArrayList<TreeNode>();
  129.         // 获取到List
  130.         treeToList(tree,list);
  131.         Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
  132.         // 将所有的数据，以键值对的形式装入map中
  133.         for (TreeNode node : list) {
  134.             // 去除冗余的子节点
  135.             node.setChildren(new ArrayList<TreeNode>());
  136.             map.put(node.getId(), node);
  137.         }
  138.        /* // 存储最小子节点ID
  139.         Map<Long,Object> leafList=new  HashMap<Long,Object>();
  140.         findMinNodes(tree,leafList,0);
  141.         // 设置每个节点的值
  142.         for (Long id_: leafList.keySet()) {
  143.             // 内部递归树的父节点层级多于2会存在重复计算
  144.             setParentNodeValue(map,id_);
  145.         }*/
  146.  
  147.         // 存储最小子节点ID
  148.         Map<Long,Object> leaf=new  HashMap<Long,Object>();
  149.         findMinNodes(tree,leaf);
  150.         // 逐级设置父节点的值
  151.         setValuesToParentNode(leaf, map);
  152.  
  153.         // 汇总所有节点的值
  154.         double total=0;
  155.         for (TreeNode node:map.values() ) {
  156.             total=0;
  157.             for (double value: node.getValues() ) {
  158.                 total+=value;
  159.             }
  160.             node.setValue(total);
  161.             map.put(node.getId(),node);
  162.         }
  163.         List<TreeNode>  result=new ArrayList<TreeNode>();
  164.         for (TreeNode node:map.values()) {
  165.             result.add(node);
  166.         }
  167.         return result;
  168.     }
  169.  
  170.     /**
  171.      * 转换数据格式并设置对应节点的值汇总到根节点
  172.      * @param list
  173.      * @param rootId
  174.      * @param columns
  175.      * @return
  176.      */
  177.     public static List<TreeNode> listToTreeWithMultiValues(List<TreeNode> list,long rootId,int columns){
  178.         Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
  179.         // 将所有的数据，以键值对的形式装入map中
  180.         for (TreeNode node : list) {
  181.             // 去除冗余的子节点
  182.             node.setChildren(new ArrayList<TreeNode>());
  183.             map.put(node.getId(), node);
  184.         }
  185.         List<TreeNode> tree=listToTree(list,rootId);
  186.  
  187.        /* // 存储最小子节点ID
  188.         Map<Long,Object> leafList=new  HashMap<Long,Object>();
  189.         findMinNodes(tree.get(0),leafList,0);
  190.         // 设置每个节点的值
  191.         for (Long id_: leafList.keySet()) {
  192.             // 内部递归树的父节点层级多于2会存在重复计算
  193.             setParentNodeMultiValues(map,id_);
  194.         }*/
  195.  
  196.         // 存储最小子节点ID
  197.         Map<Long,Object> leaf=new  HashMap<Long,Object>();
  198.         findMinNodes(tree.get(0),leaf);
  199.         // 逐级追加父节点的值
  200.         setMultiValuesToParentNode(leaf, map);
  201.  
  202.         // 汇总所有节点的值
  203.         double [] valueColumns=null;
  204.         for (TreeNode node:map.values() ) {
  205.             valueColumns=new double[columns];
  206.             for (double [] values: node.getChildrenMultiValues() ) {
  207.                 for (int i = 0,j=values.length; i < j; i++) {
  208.                     valueColumns[i]+=values[i];
  209.                 }
  210.             }
  211.             node.setMultiValues(valueColumns);
  212.             map.put(node.getId(),node);
  213.         }
  214.         List<TreeNode>  result=new ArrayList<TreeNode>();
  215.         for (TreeNode node:map.values()) {
  216.             result.add(node);
  217.         }
  218.         return listToTree(result,rootId);
  219.     }
  220.  
  221.     /**
  222.      * 转换数据格式并设置对应节点的值汇总到根节点
  223.      * @param tree
  224.      * @param columns
  225.      * @return
  226.      */
  227.     public static  List<TreeNode>  treeToListWithMultiValues(TreeNode tree,int columns){
  228.         List<TreeNode> list=new ArrayList<TreeNode>();
  229.         // 获取到List
  230.         treeToList(tree,list);
  231.         Map<Long, TreeNode> map = new HashMap<Long, TreeNode>();
  232.         // 将所有的数据，以键值对的形式装入map中
  233.         for (TreeNode node : list) {
  234.             // 去除冗余的子节点
  235.             node.setChildren(new ArrayList<TreeNode>());
  236.             map.put(node.getId(), node);
  237.         }
  238.         /*
  239.         // 存储最小子节点ID
  240.         Map<Long,Object> leafList=new  HashMap<Long,Object>();
  241.         findMinNodes(tree,leafList,0);
  242.         // 设置每个节点的值
  243.         for (Long id_: leafList.keySet()) {
  244.              // 内部递归树的父节点层级多于2会存在重复计算
  245.             setParentNodeMultiValues(map,id_);
  246.         }*/
  247.  
  248.         // 存储最小子节点ID
  249.         Map<Long,Object> leaf=new  HashMap<Long,Object>();
  250.         findMinNodes(tree,leaf);
  251.         // 逐级追加父节点的值
  252.         setMultiValuesToParentNode(leaf, map);
  253.  
  254.         // 汇总所有节点的值
  255.         double [] valueColumns=null;
  256.         for (TreeNode node:map.values() ) {
  257.             valueColumns=new double[columns];
  258.             for (double [] values: node.getChildrenMultiValues() ) {
  259.                 for (int i = 0,j=values.length; i < j; i++) {
  260.                     valueColumns[i]+=values[i];
  261.                 }
  262.             }
  263.             node.setMultiValues(valueColumns);
  264.             map.put(node.getId(),node);
  265.         }
  266.         List<TreeNode>  result=new ArrayList<TreeNode>();
  267.         for (TreeNode node:map.values()) {
  268.             result.add(node);
  269.         }
  270.         return result;
  271.     }
  272.  
  273.     /**
  274.      * 逐级追加设置节点的值（单个值）
  275.      * @param leaf
  276.      * @param map
  277.      */
  278.     public static void setValuesToParentNode(Map<Long,Object> leaf,Map<Long, TreeNode> map){
  279.         Map<Long,Object> newLeaf=new  HashMap<Long,Object>();
  280.         // 设置每个节点的值
  281.         for (Long id_: leaf.keySet()) {
  282.             setParentNodeValue(newLeaf,map,id_);
  283.         }
  284.         if(newLeaf.size()>1){
  285.             setValuesToParentNode(newLeaf, map);
  286.         }
  287.     }
  288.  
  289.     /**
  290.      * 逐级追加设置节点的值（多个值）
  291.      * @param leaf
  292.      * @param map
  293.      */
  294.     public static void setMultiValuesToParentNode( Map<Long,Object> leaf,Map<Long, TreeNode> map){
  295.         Map<Long,Object> newLeaf=new  HashMap<Long,Object>();
  296.         // 设置每个节点的值
  297.         for (Long id_: leaf.keySet()) {
  298.             setParentNodeMultiValues(newLeaf,map,id_);
  299.         }
  300.         if(newLeaf.size()>1){
  301.             setMultiValuesToParentNode(newLeaf, map);
  302.         }
  303.     }
  304.  
  305.     /**
  306.      * 数学运算
  307.      * @param mathChar
  308.      * @param dest
  309.      * @param newValue
  310.      */
  311.     public static void mathHandle(String mathChar,double dest,double newValue){
  312.         switch (mathChar) {
  313.             case "+":
  314.                 dest+=newValue;
  315.                 break;
  316.             case "-":
  317.                 dest-=newValue;
  318.                 break;
  319.             case "*":
  320.                 dest*=newValue;
  321.                 break;
  322.             case "/":
  323.                 dest/=newValue;
  324.                 break;
  325.             default:
  326.                 break;
  327.         }
  328.     }
  329.  
  330.     /**
  331.      * 查找最小子叶节点（没有子节点的节点）
  332.      * @param node
  333.      * @param leafList
  334.      */
  335.     private static void findMinNodes(TreeNode node,Map<Long,Object> leafList){
  336.         if(node.getChildren().size()>0){
  337.             TreeNode nodeTmp=null;
  338.             for (int i = 0; i < node.getChildren().size(); i++) {
  339.                 nodeTmp= node.getChildren().get(i);
  340.                 findMinNodes(nodeTmp,leafList);
  341.             }
  342.         }else{
  343.             leafList.put(node.getId(),node.getId());
  344.         }
  345.     }
  346.  
  347.     /**
  348.      * 根据ID逐级查找父节点并设置值(设置单个值逐级递归)
  349.      * @param map
  350.      * @param id
  351.      */
  352.     private static void setParentNodeValue(Map<Long,Object> newLeaf,Map<Long, TreeNode> map,long id){
  353.         TreeNode node=map.get(id);
  354.         // 设置自身节点的值
  355.         if(!node.isAddSelf()){
  356.             node.setAddSelf(true);
  357.             node.getValues().add(node.getValue());
  358.             // 更新节点数据
  359.             map.put(node.getId(),node);
  360.         }
  361.         TreeNode pNode=map.get(node.getPid());
  362.         if(pNode!=null){
  363.             // 将子节点的值赋给父节点
  364.             pNode.getValues().addAll(node.getValues());
  365.             // 设置自身节点的值
  366.             if(!pNode.isAddSelf()){
  367.                 pNode.setAddSelf(true);
  368.                 pNode.getValues().add(pNode.getValue());
  369.             }
  370.             // 更新节点数据
  371.             map.put(pNode.getId(),pNode);
  372.             //setParentNodeValue(map,pNode.getId());
  373.             newLeaf.put(pNode.getId(), pNode.getId());
  374.         }
  375.     }
  376.  
  377.     /**
  378.      * 根据ID逐级查找父节点并设置值(设置多个值逐级递归)
  379.      * @param map
  380.      * @param id
  381.      */
  382.     private static void setParentNodeMultiValues(Map<Long,Object> newLeaf,Map<Long, TreeNode> map,long id){
  383.         TreeNode node=map.get(id);
  384.         // 设置自身节点的值
  385.         if(!node.isAddSelf()){
  386.             node.setAddSelf(true);
  387.             node.getChildrenMultiValues().add(node.getMultiValues());
  388.             // 更新节点数据
  389.             map.put(node.getId(),node);
  390.         }
  391.         TreeNode pNode=map.get(node.getPid());
  392.         if(pNode!=null){
  393.             // 将子节点的值赋给父节点
  394.             pNode.getChildrenMultiValues().addAll(node.getChildrenMultiValues());
  395.             // 设置自身节点的值
  396.             if(!pNode.isAddSelf()){
  397.                 pNode.setAddSelf(true);
  398.                 pNode.getChildrenMultiValues().add(pNode.getMultiValues());
  399.             }
  400.             // 更新节点数据
  401.             map.put(pNode.getId(),pNode);
  402.             //setParentNodeMultiValues(map,pNode.getId());
  403.             newLeaf.put(pNode.getId(), pNode.getId());
  404.         }
  405.     }
  406.  
  407.     @SuppressWarnings("unused")
  408.     public static void main(String[] args) {
  409.         TreeNode tree=new TreeNode();
  410.         tree.setId(1);
  411.         tree.setLabel("顶层节点");
  412.         tree.setValue(1);
  413.         tree.setChildrenMultiValues(new ArrayList<double []>());
  414.         tree.setPid(0);
  415.  
  416.         List<TreeNode> list =new ArrayList<TreeNode>();
  417.         TreeNode node1=new TreeNode();
  418.         node1.setId(2);
  419.         node1.setLabel("子节点1");
  420.         node1.setValue(100);
  421.         node1.setMultiValues(new double[]{5,7,3});
  422.         node1.setChildrenMultiValues(new ArrayList<double []>());
  423.         node1.setPid(1);
  424.         list.add(node1);
  425.         TreeNode node2=new TreeNode();
  426.         node2.setId(3);
  427.         node2.setLabel("子节点2");
  428.         node2.setValue(10);
  429.         node2.setMultiValues(new double[]{2,5,8});
  430.         node2.setChildrenMultiValues(new ArrayList<double []>());
  431.         node2.setPid(1);
  432.         list.add(node2);
  433.  
  434.         tree.setChildren(list);
  435.  
  436.         List<TreeNode> destList=new ArrayList<TreeNode>();
  437.         TreeManager.treeToList(tree,destList);
  438.         System.out.println("tree转list完成");
  439.  
  440.         List<TreeNode> treeList=TreeManager.listToTree(destList,1);
  441.  
  442.         System.out.println("List转tree完成");
  443.  
  444.         /*******************注意单个值计算结果会影响多个值计算结果**************/
  445.  
  446.         List<TreeNode> treeListSingleValue=TreeManager.listToTreeWithSingleValue(destList,1);
  447.         System.out.println("List转tree 汇总唯一值value完成");
  448.  
  449.         List<TreeNode> treeListSingleValue2=TreeManager.treeToListWithSingleValue(tree);
  450.         System.out.println("tree转List 汇总唯一值value完成");
  451.  
  452. //        List<TreeNode> treeListMultiValues=TreeManager.listToTreeWithMultiValues(destList,1,3);
  453. //        System.out.println("List转tree 汇总多个值values完成");
  454. //
  455. //        List<TreeNode> treeListMultiValues2=TreeManager.treeToListWithMultiValues(tree,3);
  456. //        System.out.println("tree转List 汇总多个值values完成");
  457.  
  458.     }
  459. }

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

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

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/171042
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号