🚀 深入解析 Java 递归：构建层级树形结构的优雅实现 🔧
大家好！👋 今天我们来聊聊 Java 中一个非常常见的操作：通过递归构建层级树形结构。🎉 具体来说，我们将深入分析以下代码片段：
// 递归构建子树
for (InviteCode child : children) {
InviteCodeTreeDTO childNode = buildTree(child, inviteCodeMap);
node.getChildren().add(childNode);
}
这段代码是构建邀请码层级树的一部分，背后涉及了递归、树形数据结构以及 Java 的集合操作。💡 我们将从代码的背景开始，逐步拆解它的实现原理，探讨使用场景、优势和优化方法，最后通过一个实际案例展示它的应用。为了更直观地理解整个过程，我们还会插入一个 Mermaid 流程图！📊
准备好了吗？让我们开始吧！🚀
📖 背景：为什么需要递归构建树形结构？
在 Java 开发中，我们经常需要处理层级数据。例如，在一个邀请码系统中，我们有一个 List<InviteCode>，其中 InviteCode 是一个实体类，包含以下字段：
public class InviteCode {
private Integer id;
private String inviteCode;
private Integer inviteLevel;
private Integer createdBy;
// Getters and Setters
public Integer getId() {
return id;
}
public String getInviteCode() {
return inviteCode;
}
public Integer getInviteLevel() {
return inviteLevel;
}
public Integer getCreatedBy() {
return createdBy;
}
}
假设我们有一个 List<InviteCode>，包含 adminId = 7 的所有邀请码记录：
| id | admin_id | created_by | invite_code | invite_level |
|---|---|---|---|---|
| 20 | 7 | NULL | ****** | 0 |
| 21 | 7 | 20 | 263113 | 1 |
| 22 | 7 | 20 | 704358 | 1 |
| 23 | 7 | 20 | 982868 | 1 |
| 24 | 7 | NULL | ****** | 0 |
| 25 | 7 | 24 | ****** | 1 |
| 26 | 7 | 25 | ****** | 2 |
| 27 | 7 | 26 | 991476 | 3 |
我们的目标是构建一个以 adminId 为根的邀请码层级树。层级树的构建需要从根节点（createdBy == null）开始，递归地找到每个节点的子节点（createdBy 等于父节点 id）。最终，我们需要将数据转换为树形结构（InviteCodeTreeDTO），以便前端展示：
public class InviteCodeTreeDTO {
private Integer id;
private String inviteCode;
private Integer inviteLevel;
private List<InviteCodeTreeDTO> children;
// Getters and Setters
}
在 buildTree 方法中，我们已经为当前节点（root）创建了一个 InviteCodeTreeDTO（node），并找到了它的直接子节点（children）。现在，我们需要递归地为每个子节点构建子树，这就是以下代码的作用：
// 递归构建子树
for (InviteCode child : children) {
InviteCodeTreeDTO childNode = buildTree(child, inviteCodeMap);
node.getChildren().add(childNode);
}
🌟 代码拆解：一步步理解
让我们逐步拆解这段代码，弄清楚它是如何工作的！
1. for (InviteCode child : children)
- 增强型 for 循环：遍历
children列表中的每个InviteCode对象。children：一个List<InviteCode>，包含当前节点root的所有直接子节点（createdBy等于root.getId()的InviteCode对象）。child：每次循环中代表一个子节点（例如id = 21、createdBy = 20）。
- 作用：为每个子节点执行后续逻辑，生成对应的子树。
2. InviteCodeTreeDTO childNode = buildTree(child, inviteCodeMap);
buildTree：递归调用buildTree方法，传入子节点child和inviteCodeMap。child：当前处理的子节点（例如id = 21）。inviteCodeMap：一个Map<Integer, InviteCode>，用于快速查找InviteCode对象。
- 作用：
buildTree方法会递归地构建以child为根的子树，返回一个InviteCodeTreeDTO。 - 递归逻辑：
buildTree会：- 创建一个新的
InviteCodeTreeDTO（childNode），设置id、inviteCode和inviteLevel。 - 查找
child的子节点（createdBy = child.getId()）。 - 递归调用
buildTree为每个子节点构建子树。 - 返回完整的子树。
- 创建一个新的
3. node.getChildren().add(childNode)
node.getChildren()：获取当前节点node的children列表（类型为List<InviteCodeTreeDTO>）。.add(childNode)：将buildTree返回的子树（childNode）添加到node的children列表中。- 作用：将子树附加到当前节点的
children中，构建完整的树形结构。
4. 整体效果
- 遍历
children中的每个子节点（InviteCode）。 - 为每个子节点递归调用
buildTree，生成对应的子树（InviteCodeTreeDTO）。 - 将所有子树添加到当前节点
node的children列表中。 - 结果：
node包含了以root为根的完整树形结构，包括所有子节点及其子树。
📊 Mermaid 流程图：可视化递归过程
为了更直观地理解递归构建树形结构的过程，我们使用 Mermaid 流程图来展示：
- 流程说明：
- 从当前节点
node（id = 20）开始，获取其子节点（children）。 - 对每个子节点（
id = 21, 22, 23）：- 递归调用
buildTree，生成子树（childNode）。 - 将子树添加到
node.children中。
- 递归调用
- 最终，
node包含所有子树。
- 从当前节点
📝 示例：具体数据
假设 inviteCodeMap 包含以下数据（adminId = 7）：
| id | admin_id | created_by | invite_code | invite_level |
|---|---|---|---|---|
| 20 | 7 | NULL | ****** | 0 |
| 21 | 7 | 20 | 263113 | 1 |
| 22 | 7 | 20 | 704358 | 1 |
| 23 | 7 | 20 | 982868 | 1 |
| 24 | 7 | NULL | ****** | 0 |
| 25 | 7 | 24 | ****** | 1 |
| 26 | 7 | 25 | ****** | 2 |
| 27 | 7 | 26 | 991476 | 3 |
1. 当前节点：root = id = 20
children：包含id = 21, 22, 23（createdBy = 20）。- 初始化：
node是InviteCodeTreeDTO(id=20, inviteCode="******", inviteLevel=0, children=[])。
第一次循环：child = id = 21
buildTree(child, inviteCodeMap)：childNode：InviteCodeTreeDTO(id=21, inviteCode="263113", inviteLevel=1, children=[])。id = 21没有子节点（createdBy = 21的InviteCode不存在）。
node.getChildren().add(childNode)：node.children包含id = 21的子树。
第二次循环：child = id = 22
buildTree(child, inviteCodeMap)：childNode：InviteCodeTreeDTO(id=22, inviteCode="704358", inviteLevel=1, children=[])。id = 22没有子节点。
node.getChildren().add(childNode)：node.children包含id = 21, 22的子树。
第三次循环：child = id = 23
buildTree(child, inviteCodeMap)：childNode：InviteCodeTreeDTO(id=23, inviteCode="982868", inviteLevel=1, children=[])。id = 23没有子节点。
node.getChildren().add(childNode)：node.children包含id = 21, 22, 23的子树。
结果：node 是一个完整的树：
id = 20。children包含id = 21, 22, 23的子树。
2. 当前节点：root = id = 24
children：包含id = 25（createdBy = 24）。- 初始化：
node是InviteCodeTreeDTO(id=24, inviteCode="******", inviteLevel=0, children=[])。
第一次循环：child = id = 25
buildTree(child, inviteCodeMap)：childNode：InviteCodeTreeDTO(id=25, inviteCode="******", inviteLevel=1, children=[])。id = 25有子节点（id = 26，createdBy = 25）。- 递归调用
buildTree：id = 26：InviteCodeTreeDTO(id=26, inviteCode="******", inviteLevel=2, children=[])。id = 26有子节点（id = 27，createdBy = 26）。- 递归调用
buildTree：id = 27：InviteCodeTreeDTO(id=27, inviteCode="991476", inviteLevel=3, children=[])。id = 27没有子节点。
id = 26的children包含id = 27的子树。
id = 25的children包含id = 26的子树。
node.getChildren().add(childNode)：node.children包含id = 25的子树。
结果：node 是一个完整的树：
id = 24。children包含id = 25 -> 26 -> 27的子树。
🌟 为什么需要递归？
- 层级结构：邀请码数据可能有多层（例如
id = 24 -> 25 -> 26 -> 27），需要递归地处理每一层。 - 树形输出：前端需要树形结构（
InviteCodeTreeDTO），递归可以自然地构建这种嵌套结构。 - 通用性：递归方法适用于任意深度的层级数据。
最终 JSON 输出（以 adminId = 7 为例）：
{
"code": 0,
"msg": "查询成功",
"data": {
"adminId": 7,
"children": [
{
"id": 20,
"inviteCode": "******",
"inviteLevel": 0,
"children": [
{
"id": 21,
"inviteCode": "263113",
"inviteLevel": 1,
"children": []
},
{
"id": 22,
"inviteCode": "704358",
"inviteLevel": 1,
"children": []
},
{
"id": 23,
"inviteCode": "982868",
"inviteLevel": 1,
"children": []
}
]
},
{
"id": 24,
"inviteCode": "******",
"inviteLevel": 0,
"children": [
{
"id": 25,
"inviteCode": "******",
"inviteLevel": 1,
"children": [
{
"id": 26,
"inviteCode": "******",
"inviteLevel": 2,
"children": [
{
"id": 27,
"inviteCode": "991476",
"inviteLevel": 3,
"children": []
}
]
}
]
}
]
}
]
}
}
🚀 优势：为什么使用递归？
1. 代码简洁
- 递归将复杂的层级结构分解为简单的重复操作，代码更简洁。
- 对比非递归写法（需要手动维护栈或队列），递归更直观。
2. 通用性强
- 递归方法可以处理任意深度的层级数据，无需提前知道树的深度。
3. 易于扩展
- 如果需要添加额外的逻辑（例如过滤子节点），只需在
buildTree中修改即可。
🛠️ 优化建议
1. 添加循环检测
递归过程中可能存在循环引用（例如 id = 20 的 createdBy 指向 id = 21，而 id = 21 又指向 id = 20）。可以添加循环检测：
private InviteCodeTreeDTO buildTree(InviteCode root, Map<Integer, InviteCode> inviteCodeMap, Set<Integer> visited) {
if (!visited.add(root.getId())) {
throw new IllegalStateException("Detected a cycle in invite code hierarchy at ID: " + root.getId());
}
InviteCodeTreeDTO node = new InviteCodeTreeDTO();
node.setId(root.getId());
node.setInviteCode(root.getInviteCode());
node.setInviteLevel(root.getInviteLevel());
node.setChildren(new ArrayList<>());
List<InviteCode> children = inviteCodeMap.values().stream()
.filter(ic -> Objects.equals(ic.getCreatedBy(), root.getId()))
.collect(Collectors.toList());
for (InviteCode child : children) {
InviteCodeTreeDTO childNode = buildTree(child, inviteCodeMap, new HashSet<>(visited));
node.getChildren().add(childNode);
}
return node;
}
- 调用时：
for (InviteCode root : roots) { InviteCodeTreeDTO tree = buildTree(root, inviteCodeMap, new HashSet<>()); trees.add(tree); } - 效果：避免死循环。
2. 并行处理
如果 children 非常大，可以使用 parallelStream()：
children.parallelStream()
.map(child -> buildTree(child, inviteCodeMap))
.forEach(childNode -> node.getChildren().add(childNode));
- 注意：并行流适合大数据量，但在小数据量下可能有性能开销。
3. 日志记录
添加日志，跟踪子树的构建：
for (InviteCode child : children) {
logger.info("Building subtree for child node: {}", child.getId());
InviteCodeTreeDTO childNode = buildTree(child, inviteCodeMap);
node.getChildren().add(childNode);
}
- 效果：便于调试和监控。
📝 完整代码：实际应用
以下是完整的 InviteCodeService 实现，展示了如何使用递归构建层级树：
public class InviteCodeService {
private final InviteCodeRepository inviteCodeRepository;
private static final Logger logger = LoggerFactory.getLogger(InviteCodeService.class);
public InviteCodeService(InviteCodeRepository inviteCodeRepository) {
this.inviteCodeRepository = inviteCodeRepository;
}
public AdminInviteCodeTreeDTO getAdminInviteCodeTree(Integer adminId) {
List<InviteCode> inviteCodes = inviteCodeRepository.findByAdminId(adminId);
if (inviteCodes.isEmpty()) {
AdminInviteCodeTreeDTO result = new AdminInviteCodeTreeDTO();
result.setAdminId(adminId);
result.setChildren(Collections.emptyList());
return result;
}
// 将 List<InviteCode> 转换为 Map<Integer, InviteCode>
Map<Integer, InviteCode> inviteCodeMap = inviteCodes.stream()
.collect(Collectors.toMap(InviteCode::getId, ic -> ic));
// 预构建 createdBy 到子节点的映射
Map<Integer, List<InviteCode>> childrenMap = inviteCodes.stream()
.filter(ic -> ic.getCreatedBy() != null)
.collect(Collectors.groupingBy(InviteCode::getCreatedBy));
// 找到所有根节点（createdBy = NULL）
List<InviteCode> roots = inviteCodes.stream()
.filter(ic -> ic.getCreatedBy() == null)
.collect(Collectors.toList());
logger.info("Found {} root nodes for adminId {}: {}", roots.size(), adminId, roots);
// 如果没有根节点，直接返回
if (roots.isEmpty()) {
AdminInviteCodeTreeDTO result = new AdminInviteCodeTreeDTO();
result.setAdminId(adminId);
result.setChildren(Collections.emptyList());
return result;
}
// 为每个根节点构建树形结构
List<InviteCodeTreeDTO> trees = new ArrayList<>();
for (InviteCode root : roots) {
InviteCodeTreeDTO tree = buildTree(root, inviteCodeMap, childrenMap, new HashSet<>());
trees.add(tree);
}
AdminInviteCodeTreeDTO result = new AdminInviteCodeTreeDTO();
result.setAdminId(adminId);
result.setChildren(trees);
return result;
}
private InviteCodeTreeDTO buildTree(InviteCode root, Map<Integer, InviteCode> inviteCodeMap, Map<Integer, List<InviteCode>> childrenMap, Set<Integer> visited) {
if (!visited.add(root.getId())) {
throw new IllegalStateException("Detected a cycle in invite code hierarchy at ID: " + root.getId());
}
InviteCodeTreeDTO node = new InviteCodeTreeDTO();
node.setId(root.getId());
node.setInviteCode(root.getInviteCode());
node.setInviteLevel(root.getInviteLevel());
node.setChildren(new ArrayList<>());
// 直接从 childrenMap 获取子节点
List<InviteCode> children = childrenMap.getOrDefault(root.getId(), Collections.emptyList());
logger.info("Found {} children for root node {}: {}", children.size(), root.getId(), children);
// 递归构建子树
for (InviteCode child : children) {
logger.info("Building subtree for child node: {}", child.getId());
InviteCodeTreeDTO childNode = buildTree(child, inviteCodeMap, childrenMap, new HashSet<>(visited));
node.getChildren().add(childNode);
}
return node;
}
}
🎉 总结
通过递归和 buildTree 方法，我们可以轻松地构建复杂的层级树形结构，为前端提供所需的树形数据。💻
- 核心代码：
for (InviteCode child : children) { InviteCodeTreeDTO childNode = buildTree(child, inviteCodeMap); node.getChildren().add(childNode); }递归构建子树。 - 优势：代码简洁、通用性强、易于扩展。
- 优化：添加循环检测、支持并行流、添加日志。
希望这篇博客对你理解递归和树形结构构建有所帮助！💬 如果你有其他问题，欢迎留言讨论！🚀
📚 参考：Java 官方文档、递归算法原理。点赞和分享哦！😊
扫一扫
769
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
