Spring 查找多层子对象的值（使用循环？？）

我不知道如何搜索这个，所以真的没有成功。我将从我拥有的数据类开始

以下是培训计划实体（示例）

我希望我能够清楚地解释这一点，所以我在这里试图实现的是从所有之前的（培训计划）阶段获得培训

工作原理-当创建下一个（新培训计划）计划阶段时，它会使用先前的PlanID引用旧计划，以便识别其父计划（类似的层）

因此，例如，如果培训计划有第2阶段，我可以很容易地从第1阶段以类似的方式获得培训：

    public List<Training> trainingsFromPreviousPhase(TrainingPlan plan, List<TrainingPlan> planList) {
    List<Training> previousPhaseTrainings = new ArrayList<Training>();

    if (plan.getPreviousTrainingPlanId() != null) {
        TrainingPlan previousPlanPhase = planList.parallelStream()
                .filter(e -> e.getId() == plan.getPreviousTrainingPlanId()).findAny().get();
        previousPhaseTrainings = previousPlanPhase.getTrainings();

}
    return previousPhaseTrainings;
}

上一阶段的公共培训列表（培训计划，列表计划列表）{
List previousPhaseTrainings=new ArrayList（）；
if（plan.getPreviousTrainingPlanId（）！=null）{
培训计划previousPlanPhase=planList.parallelStream（）
.filter（e->e.getId（）==plan.getPreviousTrainingPlanId（））.findAny（）.get（）；
previousPhaseTrainings=previousPlanPhase.getTrainings（）；
}
返回以前的相位图；
}

现在的问题是，如果一个计划是在第五阶段，我需要从之前的四个阶段得到培训，这就是我被卡住的地方，我想不出一个方法来自动循环。我希望我解释这个不太难理解。欢迎提出任何建议或问题

这里我需要的是类似于：

List<List<Training>> getTrainingsFromAllPreviousPhases()

List getTrainingsFromAllPreviousPhases（）

您可以像这样循环执行所有计划阶段：

TrainingPlan currentPlan = plan;
List<Training> allTrainings = new ArrayList<>();
while (cirrentPlan.getPreviousTrainingPlanId() != null) {
    TrainingPlan previousPlanPhase = planList.parallelStream()
        .filter(e -> e.getId() == currentPlan.getPreviousTrainingPlanId()).findAny().get();
    allTrainings.addAll(previousPlanPhase.getTrainings());
    currentPlan = previousPlanPhase;
}

培训计划当前计划=计划；
列出所有培训=新建ArrayList（）；
while（cirrentPlan.getPreviousTrainingPlanId（）！=null）{
培训计划previousPlanPhase=planList.parallelStream（）
.filter（e->e.getId（）==currentPlan.getPreviousTrainingPlanId（））.findAny（）.get（）；
allTrainings.addAll（previousPlanPhase.getTrainings（））；
当前计划=上一个计划阶段；
}

但是，为了避免重复查看计划列表以查找id，我建议将它们保存在地图中：

Map<Long, TrainingPlan> planMap = planList.stream()
    .collect(Collectors.toMap(TrainingPlan::getId, Function.identity());

Map planMap=planList.stream（）
.collect（Collectors.toMap（TrainingPlan:：getId，Function.identity（））；

然后可以简化代码（视觉上和O（n）复杂度方面）：

培训计划当前计划=计划；
列出所有培训=新建ArrayList（）；
while（currentPlan.getPreviousTrainingPlanId（）！=null）{
培训计划previousPlanPhase=planMap.get（currentPlan.getPreviousTrainingPlanId（））；
allTrainings.addAll（previousPlanPhase.getTrainings（））；
当前计划=上一个计划阶段；
}

如果我理解正确，您正在寻找一个递归函数，即一个可以调用自身并处理任意数量嵌套级别的方法。示例：伙计们，您很完美，这正是我想要的！谢谢！！！：）

TrainingPlan currentPlan = plan;
List<Training> allTrainings = new ArrayList<>();
while (cirrentPlan.getPreviousTrainingPlanId() != null) {
    TrainingPlan previousPlanPhase = planList.parallelStream()
        .filter(e -> e.getId() == currentPlan.getPreviousTrainingPlanId()).findAny().get();
    allTrainings.addAll(previousPlanPhase.getTrainings());
    currentPlan = previousPlanPhase;
}

Map<Long, TrainingPlan> planMap = planList.stream()
    .collect(Collectors.toMap(TrainingPlan::getId, Function.identity());

TrainingPlan currentPlan = plan;
List<Training> allTrainings = new ArrayList<>();
while (currentPlan.getPreviousTrainingPlanId() != null) {
    TrainingPlan previousPlanPhase = planMap.get(currentPlan.getPreviousTrainingPlanId());
    allTrainings.addAll(previousPlanPhase.getTrainings());
    currentPlan = previousPlanPhase;
}