父子关系树或列表排序

父子关系列表排序

父节点在前,子节点在后

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
* 按父子节点排序,父节点在子节点前面
*
* @param departs 列表
* @return 排序列表
*/
public static List<Depart> sort(List<Depart> departs) {
// 先找出所有的 root 元素
Queue<Depart> queues = departs.stream()
.filter(d -> d.getParentId() == null || -1L == d.getParentId())
.collect(Collectors.toCollection(LinkedList::new));
return findChildren(departs, queues);
}

private static List<Depart> findChildren(List<Depart> departs, Queue<Depart> queues) {
List<Depart> childrenList = new ArrayList<>();
while (queues.size() > 0) {
// 弹出队列
Depart poll = queues.poll();
childrenList.add(poll);
for (Depart depart : departs) {
if (Objects.equals(depart.getParentId(), poll.getId())) {
// 加入队列
queues.offer(depart);
}
}
}
return childrenList;
}

倒序迭代

1
2
3
4
for (int i = departs.size() - 1; i >= 0; i--) {
Depart depart = departs.get(i);
log.info("部门 ---> depart: {}", depart);
}

树结构数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
* 树结构
*/
@Data
@NoArgsConstructor
public class TreeNode implements Serializable {
private static final long serialVersionUID = 3083223582409151873L;

private String id;
private String label;
private String parentId;
private List<TreeNode> children = new ArrayList<>();

/**
* 根据列表,构建树结构
*
* @param list 列表
* @param rootId 根节点 Id
* @return 树结构数据
*/
public static List<TreeNode> convert(List<TreeNode> list, String rootId) {
List<TreeNode> tree = new ArrayList<>();
Iterator<TreeNode> iterator = list.iterator();
while (iterator.hasNext()) {
TreeNode node = iterator.next();
String parentId = node.getParentId();
// 根节点
if (ObjectUtils.isEmpty(parentId) || rootId.equals(parentId)) {
tree.add(node);
iterator.remove();
}
}

for (TreeNode node : tree) {
List<TreeNode> children = TreeNode.getChildren(node, list);
node.getChildren().addAll(children);
}
return tree;
}

/**
* 获取子节点数据
*
* @param parentNode 父节点
* @param list 所有节点集合
* @return 返回子节点列表
*/
private static List<TreeNode> getChildren(TreeNode parentNode, List<TreeNode> list) {
List<TreeNode> children = new ArrayList<>();
Iterator<TreeNode> iterator = list.iterator();
while (iterator.hasNext()) {
TreeNode node = iterator.next();
// 如果当前节点 ID 与父节点 ID 一致,表示当前数据是该节点的子节点
if (parentNode.getId().equals(node.getParentId())) {
children.add(node);
iterator.remove();
}
}
// 递归调用
for (TreeNode node : children) {
// 调用自身方法,依次添加子节点数据
node.getChildren().addAll(getChildren(node, list));
}
return children;
}
}
  • 本文作者: forever杨
  • 本文链接: https://blog.yl-online.top/posts/1f7d4723.html
  • 版权声明: 本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。如果文章内容对你有用,请记录到你的笔记中。本博客站点随时会停止服务,请不要收藏、转载!