Loops 将循环内的复杂条件逻辑转换为流和lambda

我正在寻找一种干净的方法，用导致不同操作的

if

和

else

语句将复杂的逻辑条件转换为lambda和流

假设我有以下代码：

List<OuterData> result = new LinkedList<>();

for (Outer outer : getOutersFromSomewhere()) {
    OuterData outerData = new OuterData();

    if (outer.isImportant()) {
        doImportantAction(outer, outerData);
    } else if (outer.isTrivial()) {
        doTrivialAction(outer, outerData);
    } else {
        doDefaultAction(outer, outerData);
    }

    for (Inner inner : outer.getInners()) {
        if (inner.mustBeIncluded()) {
            InnerData innerData = new InnerData();

            if (inner.meetsCondition1()) {
                doAction1(inner, innerData, outer, outerData);
            } else if (inner.meetsCondition2()) {
                doAction2(inner, innerData, outer, outerData);
            } else {
                doDefaultAction(inner, innerData, outer, outerData);
            }
            outerData.add(innerData);
        }
    }
    result.add(outerData);
}

return result;

List result=newlinkedlist（）；
for（外部：getOutersFromSomewhere（））{
OuterData OuterData=新的OuterData（）；
if（outer.isImportant（））{
DOIMPORTATION（外部、外部数据）；
}else if（outer.istrival（））{
doTrivalAction（外部、外部数据）；
}否则{
doDefaultAction（外部、外部数据）；
}
for（内部：outer.getInners（））{
if（内部.必须包含（））{
InnerData InnerData=新的InnerData（）；
if（inner.meetCondition1（））{
doAction1（内部、内部数据、外部、外部数据）；
}else if（inner.meetcondition2（））{
doAction2（内部、内部数据、外部、外部数据）；
}否则{
doDefaultAction（内部、内部数据、外部、外部数据）；
}
添加（innerData）；
}
}
结果。添加（外部数据）；
}
返回结果；

这是从我的真实代码中简化出来的。我知道它可以被优化和重构，也就是说，我可以将

for

的内部方法移动到

private

方法。我想知道如何将

if

、

else-if

和

else

部分翻译成streams和lambda

---

我知道如何翻译这个例子的框架。我会使用

List.stream（）

，

stream.map（）

，

stream.filter（）

，

stream.collect（）

和

stream.peek（）

。我的问题仅限于条件分支。如何进行此转换？

第一个明显的方法是对元素进行流式处理，根据需要的条件对其进行过滤，然后对每个剩余元素应用操作。这也使代码更加清晰：

List<Outer> outers = getOutersFromSomewhere();
outers.stream().filter(Outer::isImportant)
    .forEach(outer -> doImportantAction(outer, outerDate));
outers.stream().filter(Outer::isTrivial)
    .forEach(outer -> doTrivialAction(outer, outerDate));
// default action analog

现在你可以这么简单地说：

List<Outer> outers = getOutersFromSomewhere();
outers.forEach(outer -> outer.act(...)); // place consumers here (lambdas)

List outers=getoutersfromwhere（）；
outers.forEach（outer->outer.act（…）；//将消费者放在这里（lambdas）

这有一个明显的优势：如果您必须向

外部

类添加一个特性，比如说

isComplex（）

，您只需更改单个类的内部结构（并可能解决其他部分中的编译器故障）。或者，您可以以向后兼容的方式添加此功能

---

同样的规则也可以应用于

内部
类和迭代。
也许你可以简化例子中的代码。@RaulGuiu好的，我会这样做的。谢谢，我想你们可以用几个不同的过滤器和if条件，用foreach和if主体。@RaulGuiu我已经编辑了我的问题。结构相同，不太冗长。希望现在一切都清楚了。@RaulGuiu我如何在if条件下使用一些不同的过滤器？
List<Outer> outers = getOutersFromSomewhere();
outers.forEach(outer -> outer.act(...)); // place consumers here (lambdas)