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

Question

我正在寻找一种简洁的方法，将使用 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;

这是根据我的真实代码进行简化的。我知道它可以优化和重构，即我可以将内部 for 移动到 private 方法。我想知道如何将 if、else if 和 else 部分转换为流和 lambda。

我知道如何翻译这个例子的骨架。我会使用 List.stream()、Stream.map()、Stream.filter()、Stream.collect( ) 和 Stream.peek()。我的问题仅在于条件分支。我该如何翻译？

Answer 1

第一个明显的方法是流式传输元素，根据所需的条件过滤它们，然后对每个剩余元素应用操作。这也使代码更加简洁:

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

警告:仅当重要、琐碎和默认元素形成一个分区时，此方法才有效。否则它不等同于您的 if-else 结构。但也许这是有意为之......

这种方法的主要问题是:它不是很好的 OOP。您正在查询对象以便做出决定。但 OOP 应该尽可能“告诉，不要问”。

因此，另一个解决方案是在您的 Outer 类中提供一个使用方法:

public class Outer {
    ...
    public void act(OuterData data, Consumer<Outer> importantAction,
            Consumer<Outer> trivialAction, Consumer<Outer> defaultAction) {
        if (isImportant())
            importantAction.accept(this, data);
        else if (isTrivial())
            trivialAction.accept(this, data);
        else
            defaultAction.accept(this, data);
    }
}

现在你可以这么简单地调用它:

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

这有一个明显的优势:如果您必须向 Outer 类添加一个功能 - 比如说 isComplex() - 您只需更改其内部那个单一的类(也许可以解决其他部分的编译器故障)。或者您可以以向后兼容的方式添加此功能。

相同的规则可以应用于Inner类和迭代。