第一种,却显示多层失效,最多两层
/**
* 对象List转为Tree树形结构
*
* @param entityList 传进来的泛型List
* @param primaryFieldName 主键名称
* @param parentFieldName 父级字段名称
* @return
*/
public final List<Map<String, Object>> listToTree(List<Map<String, Object>> entityList, String primaryFieldName, String parentFieldName) {
//返回的map Tree树形结构
List<Map<String, Object>> treeMap = new ArrayList<>();
//将传进的参数entityList转为MapList
List<Map<String, Object>> listMap = JSON.parseObject(JSON.toJSONString(entityList), List.class);
//声明一个map用来存listMap中的对象，key为对象id，value为对象本身
Map<String, Map<String, Object>> entityMap = new Hashtable<>();
//循环listMap把map对象put到entityMap中去
listMap.forEach(map -> entityMap.put(map.get(primaryFieldName).toString(), map));
//循环listMap进行Tree树形结构组装
listMap.forEach(map -> {
//获取map的pid
Object pid = map.get(parentFieldName);
//判断pid是否为空或者为0，为空说明是最顶级，直接add到返回的treeMap中去
if (pid == null || StringUtils.equals(pid.toString(), "0")) {
treeMap.add(map);
} else {
//如果pid不为空也不为0，是子集
// 根据当前map的pid获取上级 parentMap
Map<String, Object> parentMap = entityMap.get(pid.toString());
if (parentMap == null) { //如果parentMap为空，则说明当前map没有父级，当前map就是顶级
treeMap.add(map);
} else {
//如果parentMap不为空，则当前map为parentMap的子级
//取出parentMap的所有子级的List集合
List<Map<String, Object>> children = (List<Map<String, Object>>) parentMap.get("children");
if (children == null) { //判断子级集合是否为空，为空则新创建List
children = new ArrayList<>();
parentMap.put("children", children);
}
//把当前map对象add到parentMap的子级List中去
children.add(map);
/**
* 因为parentMap是从entityMap中get出来的，
* 而entityMap中的value又是来自于listMap对象，
* 所以parentMap和entityMap中的value的地址都是指向listMap中的对象，
* 所以parentMap的children和entityMap中的value的children改变时，都会改变listMap中的对象，
* 这里涉及到了地址、指针，就不多说了。
*/
}
}
});
return treeMap;
}第二种,for 方法转树形
public class TreeTest {
public static void main(String[] args) {
List<Tree> node = forMethod(treeList);
System.out.println(node);
}
/**
* 双重for循环方法转换成树形结构
* @param treeList
* @return
*/
public static List<Tree> forMethod(List<Tree> treeList) {
List<Tree> rootTree = new ArrayList<>();
for (Tree tree : treeList) {
// 第一步 筛选出最顶级的父节点
if (0 == tree.getParentId()) {
rootTree.add(tree);
}
// 第二步 筛选出该父节点下的所有子节点列表
for (Tree node : treeList) {
if (node.getParentId().equals(tree.getId())) {
if (CollectionUtils.isEmpty(tree.getChildren())) {
tree.setChildren(new ArrayList<>());
}
tree.getChildren().add(node);
}
}
}
return rootTree;
}
}第三种,传统递归,玩不好容易死循环
public class TreeTest {
public static void main(String[] args) {
List<Tree> node = recursionMethod(treeList);
System.out.println(node);
}
/**
* 递归方法转换成树形结构
* @param treeList
* @return
*/
public static List<Tree> recursionMethod(List<Tree> treeList) {
List<Tree> trees = new ArrayList<>();
for (Tree tree : treeList) {
// 找出父节点
if (0 == tree.getParentId()) {
// 调用递归方法填充子节点列表
trees.add(findChildren(tree, treeList));
}
}
return trees;
}
/**
* 递归方法
* @param tree 父节点对象
* @param treeList 所有的List
* @return
*/
public static Tree findChildren(Tree tree, List<Tree> treeList) {
for (Tree node : treeList) {
if (tree.getId().equals(node.getParentId())) {
if (tree.getChildren() == null) {
tree.setChildren(new ArrayList<>());
}
// 递归 调用自身
tree.getChildren().add(findChildren(node, treeList));
}
}
return tree;
}
}第四种,推荐stream方法转树形
public class TreeTest {
public static void main(String[] args) {
List<Tree> node = recursionMethod(treeList);
System.out.println(node);
}
/**
* stream方法转换成树形结构
* @param treeList
* @return
*/
public static List<Tree> streamMethod(List<Tree> treeList) {
List<Tree> list = treeList.stream()
// 筛选出父节点
.filter(t -> t.getParentId() == 0)
// 设置父节点的子节点列表
.map(item -> {item.setChildren(streamGetChildren(item, treeList)); return item;})
.collect(Collectors.toList());
return list;
}
/**
* stream 方式递归查找子节点列表
* @return
*/
public static List<Tree> streamGetChildren(Tree tree, List<Tree> treeList) {
List<Tree> list = treeList.stream()
.filter(t -> t.getParentId().equals(tree.getId()))
.map(item -> {item.setChildren(streamGetChildren(item, treeList)); return item;})
.collect(Collectors.toList());
return list;
}
}关于第四种的两种优化方式
// 第一种优化，我们合并上述两个方法的相同部分
public class TreeTest {
public static void main(String[] args) {
List<Tree> node = streamMethod(0, treeList);
System.out.println(node);
}
/**
* stream 方法转换树形结构方法的优化
* @param parentId
* @param treeList
* @return
*/
public static List<Tree> streamMethod(Integer parentId, List<Tree> treeList) {
List<Tree> list = treeList.stream()
// 筛选父节点
.filter(t -> t.getParentId().equals(parentId))
// 递归设置子节点
.map(item -> {
item.setChildren(streamMethod(item.getId(), treeList));
return item;
})
.collect(Collectors.toList());
return list;
}
}
// 第二种优化，只是写法的不同，核心思路不变
public class TreeTest {
public static void main(String[] args) {
List<Tree> node = streamMethod(0, treeList);
System.out.println(node);
}
/**
* stream 方法转换树形结构方法的优化
* @param parentId
* @param treeList
* @return
*/
public static List<Tree> streamMethod(Integer parentId, List<Tree> treeList) {
List<Tree> list = new ArrayList<>();
Optional.ofNullable(treeList).orElse(new ArrayList<>())
.stream()
// 第一次筛选出主父节点列表进入循环，循环里面 进入递归 筛选出递归传递的从父节点列表
.filter(root -> root.getParentId().equals(parentId))
// 递归，最末的父节点从整个列表筛选出它的子节点列表依次组装
.forEach(tree -> {
List<Tree> children = streamMethod(tree.getId(), treeList);
tree.setChildren(children);
list.add(tree);
});
return list;
}
}
