package cn.exrick.xboot.modules.bill.entity;
import com.alibaba.fastjson.JSON;
import java.util.*;
/**
 * zae
*/
public class BillNodeTree {
public static Map getTreeList(List<BillCirculation> billCirculationList) {
    // 读取层次数据结果集列表
    List dataList = VirtualDataGenerator.getVirtualResult(billCirculationList);
    if(dataList==null || dataList.size()==0){
        return new HashMap();
    }
    // 节点列表（散列表，用于临时存储节点对象）
    HashMap nodeList = new HashMap();
    // 根节点
    Node root = null;
    // 根据结果集构造节点列表（存入散列表）
    for (Iterator it = dataList.iterator(); it.hasNext();) {
        Map dataRecord = (Map) it.next();
        Node node = new Node();
        node.id = (String)dataRecord.get("id");
        node.orgIssueUnitUnnoName = (String) dataRecord.get("orgIssueUnitUnnoName");
        node.level = Integer.parseInt(dataRecord.get("level")+"");
        node.parentId = (String)dataRecord.get("parentId");
        nodeList.put(node.id, node);
    }
    // 构造无序的多叉树
    Set entrySet = nodeList.entrySet();
    for (Iterator it = entrySet.iterator(); it.hasNext();) {
        Node node = (Node) ((Map.Entry) it.next()).getValue();
        if (node.parentId == null || node.parentId.equals("") || "null".equals(node.parentId)) {
            root = node;
        } else {
            ((Node) nodeList.get(node.parentId)).addChild(node);
        }
    }
    // 输出无序的树形菜单的JSON字符串
   // System.out.println(root.toString());
    // 对多叉树进行横向排序
   // root.sortChildren();
    // 输出有序的树形菜单的JSON字符串
    Map operatorMaps = (Map) JSON.parseObject(root.toString(),Map.class);
    return  operatorMaps;
}
}

/**
 * 节点类
*/
class Node {
/**
 * 节点编号
 */
public String id;
/**
 * 节点内容
 */
public String orgIssueUnitUnnoName;
/**
 * 级别
 */
public Integer level;
/**
 * 父节点编号
 */
public String parentId;
/**
 * 孩子节点列表
 */
private Children children = new Children();

// 先序遍历，拼接JSON字符串
public String toString() {
    String result = "{"
            + "id : '" + id + "'"
            + ", orgIssueUnitUnnoName : '" + orgIssueUnitUnnoName + "'"
    + ", level : " + level + "";

    if (children != null && children.getSize() != 0) {
        result += ", children : " + children.toString();
    } else {
        result += ", expand : false";
    }

    return result + "}";
}

// 兄弟节点横向排序
public void sortChildren() {
    if (children != null && children.getSize() != 0) {
        children.sortChildren();
    }
}

// 添加孩子节点
public void addChild(Node node) {
    this.children.addChild(node);
}
}

/**
* @author zangchuanlei
* 孩子列表类
*/
class Children {
private List list = new ArrayList();

public int getSize() {
    return list.size();
}

public void addChild(Node node) {
    list.add(node);
}

// 拼接孩子节点的JSON字符串
public String toString() {
    String result = "[";
    for (Iterator it = list.iterator(); it.hasNext();) {
        result += ((Node) it.next()).toString();
        result += ",";
    }
    result = result.substring(0, result.length() - 1);
    result += "]";
    return result;
}

// 孩子节点排序
public void sortChildren() {
    // 对本层节点进行排序
    // 可根据不同的排序属性，传入不同的比较器，这里传入ID比较器
    Collections.sort(list, new NodeIDComparator());
    // 对每个节点的下一层节点进行排序
    for (Iterator it = list.iterator(); it.hasNext();) {
        ((Node) it.next()).sortChildren();
    }
}
}

/**
 * @author zangchuanlei
 * 节点比较器
 */
class NodeIDComparator implements Comparator {
    // 按照节点编号比较
    public int compare(Object o1, Object o2) {
        int j1 = Integer.parseInt(((Node)o1).id);
        int j2 = Integer.parseInt(((Node)o2).id);
        return (j1 < j2 ? -1 : (j1 == j2 ? 0 : 1));
    }
}

/**
 * @author zangchuanlei
 * 构造虚拟的层次数据
 */
class VirtualDataGenerator {
    // 构造无序的结果集列表，实际应用中，该数据应该从数据库中查询获得；
    public static List getVirtualResult(List<BillCirculation> billCirculationList) {
        List dataList = new ArrayList();
        for(BillCirculation billCirculation:billCirculationList){
            HashMap dataRecord1 = new HashMap();
            dataRecord1.put("id", billCirculation.getId());
            dataRecord1.put("orgIssueUnitUnnoName",billCirculation.getCorpName());
            dataRecord1.put("level",billCirculation.getLevel());
            if(billCirculation.getLevel() == 1){
                dataRecord1.put("parentId", "");
            }else{
                String parentId = null;
                for(BillCirculation billCirculation1:billCirculationList){
                    if(billCirculation.getIssueUnitUnno().equals(billCirculation1.getSignInUnitUnno())
                    && billCirculation1.getLevel() == billCirculation.getLevel()-1){
                        parentId = billCirculation1.getId();
                    }
                }
                dataRecord1.put("parentId",parentId);
            }
            dataList.add(dataRecord1);
        }
        return dataList;
    }
}

import java.util.List;
public class Tree {
private Integer id;//id(唯一标识)
private String number;//编号
private String name;//名称
private Integer parentId;//父节点的ID代号
private Integer myId;//我的ID代号
//正式连接数据库的项目中，此为添加的属性，不是数据库映射字段
private List<Tree> children;

public Tree() {}
public Tree(Integer id, String number, String name, Integer parentId, Integer myId, List<Tree> children) {
    this.id = id;
    this.number = number;
    this.name = name;
    this.parentId = parentId;
    this.myId = myId;
    this.children = children;
}

public Integer getId() {
    return id;
}

public void setId(Integer id) {
    this.id = id;
}

public String getNumber() {
    return number;
}

public void setNumber(String number) {
    this.number = number;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public Integer getParentId() {
    return parentId;
}

public void setParentId(Integer parentId) {
    this.parentId = parentId;
}

public Integer getMyId() {
    return myId;
}

public void setMyId(Integer myId) {
    this.myId = myId;
}

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

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

import com.alibaba.fastjson.JSON;
import com.zaevn.entity.Tree;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class LambdaRecursion {
public static void main(String[] args) {
    //获取所有待处理的数据
    List<Tree> treeList = getAllTree();
    List<Tree> collect = treeList.stream()
            //筛选出所有的一级数据（父树不存在）
            .filter(tree -> tree.getParentId() == 0)
            //为一级节点数据设置孩子（调用写的获取子树的递归方法）
            .map(tree -> {
                tree.setChildren(getChrildren(tree, treeList));
                return tree;
            }).collect(Collectors.toList());
    //输出一下处理好的数据
    System.out.println(JSON.toJSONString(collect));
}
/**
 * 递归获取子树
 * @param root 父树实体
 * @param all  全部数据
 * @return
 */
private static List<Tree> getChrildren(Tree root,List<Tree> all){
    List<Tree> treeList = all.stream()
            //筛选出源节点的子节点
            .filter(tree -> tree.getParentId() == root.getMyId())
            //给当前节点设置子树，调用自身获取子树的递归方法
            .map(tree -> {
                tree.setChildren(getChrildren(tree, all));
                return tree;
            }).collect(Collectors.toList());
    return treeList;
}
/**
 * 数据准备类
 * （实际开发中不存在此方法，应该在数据库中获取数据）
 * @return
 */
private static List<Tree> getAllTree(){
    Tree one = new Tree(1001,"1001","皇帝",0,1,new ArrayList<>());
    Tree two1 = new Tree(1002,"1002","耶稣",1,2,new ArrayList<>());
    Tree two2 = new Tree(1003,"1003","鬼影",1,3,new ArrayList<>());
    Tree three1 = new Tree(1004,"1004","军师",2,4,new ArrayList<>());
    Tree three2 = new Tree(1005,"1005","野兽",2,5,new ArrayList<>());
    Tree three3 = new Tree(1006,"1006","伯爵",3,6,new ArrayList<>());
    Tree three4 = new Tree(1007,"1007","牧师",3,7,new ArrayList<>());
    //实际应用中需要在数据库中获取全部的数据
    List<Tree> treeList = Arrays.asList(one,two1,two2,three1,three2,three3,three4);
    return treeList;
}
}

[{"children":[{"children":[{"children":[],"id":1004,"myId":4,"name":"军师","number":"1004","parentId":2},{"children":[],"id":1005,"myId":5,"name":"野兽","number":"1005","parentId":2}],"id":1002,"myId":2,"name":"耶稣","number":"1002","parentId":1},{"children":[{"children":[],"id":1006,"myId":6,"name":"伯爵","number":"1006","parentId":3},{"children":[],"id":1007,"myId":7,"name":"牧师","number":"1007","parentId":3}],"id":1003,"myId":3,"name":"鬼影","number":"1003","parentId":1}],"id":1001,"myId":1,"name":"皇帝","number":"1001","parentId":0}]