java 生成树结构, 使用 stream + lambda

树节点模型

package org.springblade.shubh.controller;

import lombok.Data;

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

@Data
public class TreeNode {
	private Integer id;

	private Integer parentId;

	private List<TreeNode> childrenList = new ArrayList();
}

第一种方式
将数据先构建成hash结构, 然后遍历list通过hash来进行判断, 源数据作为子节点

	public static List<TreeNode> getchildTreeList(List<TreeNode> list, int id) {
		// list 转 map
		Map<Integer, TreeNode> map = list.stream().collect(Collectors.toMap(e -> e.getId(), e -> e));
		// 构建根节点数据
		TreeNode parentNode = new TreeNode();
		parentNode.setParentId(-1);
		parentNode.setId(id);
		map.put(id,parentNode);
		// 遍历源数据,以源数据作为子节点, 并通过map来获取该源数据的父节点
		list.forEach(e -> {
				if (map.containsKey(e.getParentId())) {
					map.get(e.getParentId()).getChildrenList().add(e);
				}
			}
		);
		// 返回根节点数据
		// 注: getOrDefault(key, defaultValue) 方法,  如果 map 通过key 获取的数据为空, 则返回 defaultValue, 否则返回获取到的数据
		return map.getOrDefault(id, new TreeNode()).getChildrenList();
	}

第二种写法
也是将数据先构建成hash结构, 然后遍历list通过hash来进行判断
不同的是, 先进行分组转换. 源数据作为父节点

	public static List<TreeNode> getchildTreeList(List<TreeNode> list,Integer id) {
		// 先将源数据通过parentId进行分组 并转换为 map
		Map<Integer, List<TreeNode>> map =
			list.stream().collect(Collectors.groupingBy(TreeNode::getParentId));

		// 遍历源数据 以源数据作为父节点, 通过map获取该源数据的子集数据
		for (TreeNode object : list) {
			List<TreeNode> children = map.get(object.getId());
			object.setChildrenList(children);  // 这里可以根据需要决定要不要在 children 是 null 时转换成空列表
		}
		// 根节点id
		return map.get(id);
	}

以上灵感来自于 leetcode 的简单题目<两数之和>

package org.springblade.shubh.controller;

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

public class Demo {

	public static void main(String[] args) {
		List<TreeNode> list = getList();
		List<TreeNode> menuTreeNodes = getchildTreeList(list, 0);
		System.out.println(menuTreeNodes);

		List<TreeNode> menuTreeNodes1 = getchildTreeListTwo(list,0);
		System.out.println(menuTreeNodes);
	}

	public static List<TreeNode> getList(){
		List<TreeNode> list = new ArrayList<>();
		TreeNode node1 = new TreeNode();
		node1.setId(1);
		node1.setParentId(0);
		TreeNode node2 = new TreeNode();
		TreeNode node3 = new TreeNode();
		TreeNode node4 = new TreeNode();
		TreeNode node5 = new TreeNode();
		TreeNode node6 = new TreeNode();
		TreeNode node7 = new TreeNode();
		TreeNode node8 = new TreeNode();
		TreeNode node9 = new TreeNode();
		TreeNode node10 = new TreeNode();
		TreeNode node11 = new TreeNode();
		node2.setId(2);
		node2.setParentId(1);
		node3.setId(3);
		node3.setParentId(0);
		node4.setId(4);
		node4.setParentId(3);
		node5.setId(5);
		node5.setParentId(3);
		node6.setId(6);
		node6.setParentId(5);
		node7.setId(7);
		node7.setParentId(6);
		node8.setId(8);
		node8.setParentId(7);
		node9.setId(9);
		node9.setParentId(8);
		node10.setId(10);
		node10.setParentId(1);
		node11.setId(11);
		node11.setParentId(0);

		list.add(node1);
		list.add(node2);
		list.add(node3);
		list.add(node4);
		list.add(node5);
		list.add(node6);
		list.add(node7);
		list.add(node8);
		list.add(node9);
		list.add(node10);
		list.add(node11);
		return list;
	}

	public static List<TreeNode> getchildTreeList(List<TreeNode> list, int id) {
		// list 转 map
		Map<Integer, TreeNode> map = list.stream().collect(Collectors.toMap(e -> e.getId(), e -> e));
		// 构建根节点数据
		TreeNode parentNode = new TreeNode();
		parentNode.setParentId(-1);
		parentNode.setId(id);
		map.put(id,parentNode);
		// 遍历源数据,以源数据作为子节点, 并通过map来获取该源数据的父节点
		list.forEach(e -> {
				if (map.containsKey(e.getParentId())) {
					map.get(e.getParentId()).getChildrenList().add(e);
				}
			}
		);
		// 返回根节点数据
		// 注: getOrDefault(key, defaultValue) 方法,  如果 map 通过key 获取的数据为空, 则返回 defaultValue, 否则返回获取到的数据
		return map.getOrDefault(id, new TreeNode()).getChildrenList();
	}


	/*****************************/
	public static List<TreeNode> getchildTreeListTwo(List<TreeNode> list,Integer id) {
		// 先将源数据通过parentId进行分组 并转换为 map
		Map<Integer, List<TreeNode>> map =
			list.stream().collect(Collectors.groupingBy(TreeNode::getParentId));

		// 遍历源数据 以源数据作为父节点, 通过map获取该源数据的子集数据
		for (TreeNode object : list) {
			List<TreeNode> children = map.get(object.getId());
			object.setChildrenList(children);  // 这里可以根据需要决定要不要在 children 是 null 时转换成空列表
		}
		// 根节点id
		return map.get(id);
	}
}