list转tree和list中查找某节点下的所有数据操作

类的实例化顺序

父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、

父类非静态变量（父类实例成员变量）、父类构造函数、子类非静态变量（子类实例成员变量）、子类构造函数。

已知组织类Org{String id,String name,String parentId}，现在一List中存放无序的Org数据，求一个组织id下的所有组织。

public static List childList=new ArrayList<>(); 
public static List findChild(List list,String id){
   for (Org org:list){
    if(org.getParentId().equals(id)){
     childList.add(org);
     findChild(list,org.getId()); //递归实现
 
    }
  }
  return childList;
  }

list转tree:

 // node一开始为根节点
 public static TreeNode listToTree(TreeNode node, List sourceLit){
  // 重根节点开始
  for (TreeNode sourceNode : sourceLit){
   if (sourceNode.getpId() == node.getId()){
     if(node.getChildrenList() == null){
      node.setChildrenList(new ArrayList());
     }
     node.getChildrenList().add(listToTree(sourceNode, sourceLit));
   }
  }
  return node;
 }

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

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

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

构造一棵树的基本节点：

package com.example.demo.tree; 
import java.util.ArrayList;
import java.util.List;
 

public class TreeNode {
 
 
 private long id;
 
 private String label;
 
 private double value;
 
 private double[] multiValues=new double[]{};
 
 private List values=new ArrayList();
 
 private List childrenMultiValues=new ArrayList();
 
 private long pid;
 
 private List children=new ArrayList();
 
 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 getValues() {
  return values;
 }
 
 public void setValues(List values) {
  this.values = values;
 }
 
 public List getChildrenMultiValues() {
  return childrenMultiValues;
 }
 
 public void setChildrenMultiValues(List childrenMultiValues) {
  this.childrenMultiValues = childrenMultiValues;
 }
 
 public long getPid() {
  return pid;
 }
 
 public void setPid(long pid) {
  this.pid = pid;
 }
 
 public List getChildren() {
  return children;
 }
 
 public void setChildren(List 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;

public class TreeManager {
 
 
 public static List listToTree(List list,long rootId){
  List tree=new ArrayList();
  Map map = new HashMap();
  // 将所有的数据，以键值对的形式装入map中
  for (TreeNode node : list) {
   // 去除冗余的子节点
   node.setChildren(new ArrayList());
   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;
 }
 
 
 public static void treeToList(TreeNode node,List list){
  if(list==null){
   list=new ArrayList();
  }
  //设置当前节点的必要数据
  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());
  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);
   }
  }
 }
 
 
 public static List listToTreeWithSinglevalue(List list,long rootId){
  Map map = new HashMap();
  // 将所有的数据，以键值对的形式装入map中
  for (TreeNode node : list) {
   // 去除冗余的子节点
   node.setChildren(new ArrayList());
   map.put(node.getId(), node);
  }
  List tree=listToTree(list,rootId);
  
 
  // 存储最小子节点ID
  Map leaf=new HashMap();
  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 result=new ArrayList();
  for (TreeNode node:map.values()) {
   result.add(node);
  }
  return listToTree(result,rootId);
 }
 
 
 public static List treeToListWithSinglevalue(TreeNode tree){
  List list=new ArrayList();
  // 获取到List
  treeToList(tree,list);
  Map map = new HashMap();
  // 将所有的数据，以键值对的形式装入map中
  for (TreeNode node : list) {
   // 去除冗余的子节点
   node.setChildren(new ArrayList());
   map.put(node.getId(), node);
  }
  
 
  // 存储最小子节点ID
  Map leaf=new HashMap();
  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 result=new ArrayList();
  for (TreeNode node:map.values()) {
   result.add(node);
  }
  return result;
 }
 
 
 public static List listToTreeWithMultiValues(List list,long rootId,int columns){
  Map map = new HashMap();
  // 将所有的数据，以键值对的形式装入map中
  for (TreeNode node : list) {
   // 去除冗余的子节点
   node.setChildren(new ArrayList());
   map.put(node.getId(), node);
  }
  List tree=listToTree(list,rootId);
 
  
 
  // 存储最小子节点ID
  Map leaf=new HashMap();
  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 result=new ArrayList();
  for (TreeNode node:map.values()) {
   result.add(node);
  }
  return listToTree(result,rootId);
 }
 
 
 public static List treeToListWithMultiValues(TreeNode tree,int columns){
  List list=new ArrayList();
  // 获取到List
  treeToList(tree,list);
  Map map = new HashMap();
  // 将所有的数据，以键值对的形式装入map中
  for (TreeNode node : list) {
   // 去除冗余的子节点
   node.setChildren(new ArrayList());
   map.put(node.getId(), node);
  }
  
 
  // 存储最小子节点ID
  Map leaf=new HashMap();
  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 result=new ArrayList();
  for (TreeNode node:map.values()) {
   result.add(node);
  }
  return result;
 }
 
 
 public static void setValuesToParentNode(Map leaf,Map map){
  Map newLeaf=new HashMap();
  // 设置每个节点的值
  for (Long id_: leaf.keySet()) {
   setParentNodevalue(newLeaf,map,id_);
  }
  if(newLeaf.size()>1){
   setValuesToParentNode(newLeaf, map);
  }
 }
 
 
 public static void setMultiValuesToParentNode( Map leaf,Map map){
  Map newLeaf=new HashMap();
  // 设置每个节点的值
  for (Long id_: leaf.keySet()) {
   setParentNodeMultiValues(newLeaf,map,id_);
  }
  if(newLeaf.size()>1){
   setMultiValuesToParentNode(newLeaf, map);
  }
 }
 
 
 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;
  }
 }
 
 
 private static void findMinNodes(TreeNode node,Map 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());
  }
 }
 
 
 private static void setParentNodevalue(Map newLeaf,Map 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());
  }
 }
 
 
 private static void setParentNodeMultiValues(Map newLeaf,Map 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());
  tree.setPid(0);
 
  List list =new ArrayList();
  TreeNode node1=new TreeNode();
  node1.setId(2);
  node1.setLabel("子节点1");
  node1.setValue(100);
  node1.setMultiValues(new double[]{5,7,3});
  node1.setChildrenMultiValues(new ArrayList());
  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());
  node2.setPid(1);
  list.add(node2);
 
  tree.setChildren(list);
 
  List destList=new ArrayList();
  TreeManager.treeToList(tree,destList);
  System.out.println("tree转list完成");
 
  List treeList=TreeManager.listToTree(destList,1);
 
  System.out.println("List转tree完成");
 
  
 
  List treeListSinglevalue=TreeManager.listToTreeWithSinglevalue(destList,1);
  System.out.println("List转tree 汇总唯一值value完成");
 
  List treeListSinglevalue2=TreeManager.treeToListWithSinglevalue(tree);
  System.out.println("tree转List 汇总唯一值value完成");
 
//  List treeListMultiValues=TreeManager.listToTreeWithMultiValues(destList,1,3);
//  System.out.println("List转tree 汇总多个值values完成");
//
//  List treeListMultiValues2=TreeManager.treeToListWithMultiValues(tree,3);
//  System.out.println("tree转List 汇总多个值values完成");
 
 }
}

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

Github源码：点击进入

以上这篇list转tree和list中查找某节点下的所有数据操作就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持考高分网。

list转tree和list中查找某节点下的所有数据操作

Java相关栏目本月热门文章