jdk8不使用递归生成节点树代码

jdk8之前一般生成节点之类的基本上都是使用递归生成的，递归大家都知道节点树越深，性能消耗越大，本文通过jdk8的新特性不需要递归也可以实现节点树的生成，而且因为不是递归，当节点树越深的时候，性能消耗也没有递归大。废话不多说，直接上代码！有意见可以在评论区交流。
测试用实体类:Role.java

package com.demo;

import java.util.List;

public class Role {

  private Long id;
  private Long pid;
  private String roleName;
  private List<Role> childerns;

  public Long getId() {
    return id;
  }

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

  public Long getPid() {
    return pid;
  }

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

  public String getRoleName() {
    return roleName;
  }

  public void setRoleName(String roleName) {
    this.roleName = roleName;
  }

  public List<Role> getChilderns() {
    return childerns;
  }

  public void setChilderns(List<Role> childerns) {
    this.childerns = childerns;
  }

  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((id == null) ? 0 : id.hashCode());
    return result;
  }

  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    Role other = (Role) obj;
    if (id == null) {
      if (other.id != null)
        return false;
    } else if (!id.equals(other.id))
      return false;
    return true;
  }

  @Override
  public String toString() {
    return "Role [id=" + id + ", pid=" + pid + ", roleName=" + roleName + ", childerns=" + childerns + "]";
  }


}

测试数据是，两个顶级角色，总经理 和 总管理者， 总经理 --> 地区经理 和 分区经理 ； 总管理者 --> 高级管理者 --> 中级管理者 --> 低级管理者
使用jdk8的新特性，不使用递归完成节点代码：

package com.demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.alibaba.fastjson.JSONObject;

public class JavaRootTreeTest {

  public static void main(String[] args) {
    JavaRootTreeTest t = new JavaRootTreeTest();
    List<Role> roles = t.findAllRoles();
    System.out.println(roles);
    List<Role> root = t.getRootTree(roles);
    System.out.println(JSONObject.toJSONString(root));
  }

  public List<Role> getRootTree(List<Role> roles) {
    if (roles == null || roles.size() == 0) {
      return Collections.emptyList();
    }
    Map<Long, Role> idMap = roles.parallelStream().collect(Collectors.toMap(Role::getId, p -> p));
    // System.out.println(idMap);
    Map<Long, List<Role>> pidGroupRolesMap = roles.parallelStream().collect(Collectors.groupingBy(Role::getPid));
    System.out.println(pidGroupRolesMap);
    pidGroupRolesMap.forEach((k, v) -> {
      Role parentRole = idMap.get(k);
      if (parentRole != null) {
        parentRole.setChilderns(v);
      }
    });
    System.out.println(pidGroupRolesMap);
    return pidGroupRolesMap.get(0L);
  }

  public List<Role> findAllRoles() {
    List<Role> roles = new ArrayList<Role>();
    Role role1 = new Role();
    role1.setId(1L);
    role1.setPid(0L);
    role1.setRoleName("总管理者");
    roles.add(role1);
    Role role2 = new Role();
    role2.setId(2L);
    role2.setPid(1L);
    role2.setRoleName("高级管理者");
    roles.add(role2);
    Role role3 = new Role();
    role3.setId(3L);
    role3.setPid(2L);
    role3.setRoleName("中级管理者");
    roles.add(role3);
    Role role4 = new Role();
    role4.setId(4L);
    role4.setPid(3L);
    role4.setRoleName("低级管理者");
    roles.add(role4);
    Role role5 = new Role();
    role5.setId(5L);
    role5.setPid(0L);
    role5.setRoleName("总经理");
    roles.add(role5);
    Role role6 = new Role();
    role6.setId(6L);
    role6.setPid(5L);
    role6.setRoleName("地区经理");
    roles.add(role6);
    Role role7 = new Role();
    role7.setId(7L);
    role7.setPid(5L);
    role7.setRoleName("分区经理");
    roles.add(role7);
    return roles;
  }
}

测试数据是，两个顶级角色，总经理 和 总管理者， 总经理 --> 地区经理 和 分区经理 ； 总管理者 --> 高级管理者 --> 中级管理者 --> 低级管理者
运行结果如下：

[
	{
		"childerns": [
			{
				"childerns": [
					{
						"childerns": [
							{
								"id": 4,
								"pid": 3,
								"roleName": "低级管理者"
							}
						],
						"id": 3,
						"pid": 2,
						"roleName": "中级管理者"
					}
				],
				"id": 2,
				"pid": 1,
				"roleName": "高级管理者"
			}
		],
		"id": 1,
		"pid": 0,
		"roleName": "总管理者"
	},
	{
		"childerns": [
			{
				"id": 6,
				"pid": 5,
				"roleName": "地区经理"
			},
			{
				"id": 7,
				"pid": 5,
				"roleName": "分区经理"
			}
		],
		"id": 5,
		"pid": 0,
		"roleName": "总经理"
	}
]