Java 8函数式编程避免if条件

如何使用纯函数式编程（不使用if条件）实现以下transform（）方法的等效功能

梅塔：如果能编辑一下标题，我会很感激的，我不知道如何在“无功能”一词中表达这个问题

公共课操场{
私有静态可选转换（列表输入）{
if（input.stream（）.anyMatch（t->t.second.isEmpty（））返回Optional.empty（）；
Map theMap=input.stream（）
.map（t->新元组（t.first，t.second.get（））
.collect（收集器.groupingBy(
t1->t1。首先，
Collectors.mapping（t2->t2.second，toSingle（））；
返回可选的.of（主题地图）；
}
@试验
公开募捐{
List input1=new ArrayList（）；
input1.add（新元组（“foo”，可选的第（1）部分）；
input1.add（新元组（“bar”，可选.empty（））；
可选结果1=转换（输入1）；
assertTrue（result1.isEmpty（））；
List input2=new ArrayList（）；
input2.add（新元组（“foo”，可选的第（1）部分）；
input2.add（新元组（“bar”，可选）（共（2））；
可选结果2=转换（输入2）；
assertTrue（result2.isPresent（））；
assertEquals（（int）1，（int）result2.get（）.get（“foo”））；
assertEquals（（int）2，（int）result2.get（）.get（“bar”）；
}
私有静态类元组{
公共T1优先；
公众T2秒；
公共元组（T1第一，T2第二）{
this.first=first；
这个秒=秒；
}
}
公共静态收集器toSingle（）{
返回收集器。正在收集，然后返回(
Collectors.toList（），
列表->列表。获取（0）
);
}
}

虽然我的解不能满足您的结果，但我可以提供一个三元运算符的解

private static Map<String, Integer> transform(List<Tuple<String, Optional<Integer>>> input) {
    return input.stream().anyMatch(t -> t.second.isEmpty()) ? Collections.emptyMap() :
            input.stream()
                    .map(t -> new Tuple<>(t.first, t.second.get()))
                    .collect(Collectors.groupingBy(
                            t1 -> t1.first,
                            Collectors.mapping(t2 -> t2.second, toSingle())));
}

私有静态映射转换（列表输入）{
返回input.stream（）.anyMatch（t->t.second.isEmpty（））？Collections.emptyMap（）：
input.stream（）
.map（t->新元组（t.first，t.second.get（））
.collect（收集器.groupingBy(
t1->t1。首先，
Collectors.mapping（t2->t2.second，toSingle（））；
}

虽然我的解不能满足您的结果，但我可以提供一个三元运算符的解

private static Map<String, Integer> transform(List<Tuple<String, Optional<Integer>>> input) {
    return input.stream().anyMatch(t -> t.second.isEmpty()) ? Collections.emptyMap() :
            input.stream()
                    .map(t -> new Tuple<>(t.first, t.second.get()))
                    .collect(Collectors.groupingBy(
                            t1 -> t1.first,
                            Collectors.mapping(t2 -> t2.second, toSingle())));
}

私有静态映射转换（列表输入）{
返回input.stream（）.anyMatch（t->t.second.isEmpty（））？Collections.emptyMap（）：
input.stream（）
.map（t->新元组（t.first，t.second.get（））
.collect（收集器.groupingBy(
t1->t1。首先，
Collectors.mapping（t2->t2.second，toSingle（））；
}

这可能适合您：

私有静态可选转换(
列表输入）{
返回可选的.of（输入）
.filter（t->t.stream（）.allMatch（a->a.second.isPresent（））
.地图(
在->
in.stream（）
.filter（t->t.second.isPresent（））
.map（t->新元组（t.first，t.second.get（））
.收集(
收集者分组(
t1->t1.first，collector.mapping（t2->t2.second，toSingle（））；
}

这可能适合您：

私有静态可选转换(
列表输入）{
返回可选的.of（输入）
.filter（t->t.stream（）.allMatch（a->a.second.isPresent（））
.地图(
在->
in.stream（）
.filter（t->t.second.isPresent（））
.map（t->新元组（t.first，t.second.get（））
.收集(
收集者分组(
t1->t1.first，collector.mapping（t2->t2.second，toSingle（））；
}

“纯函数式编程”本身不一定是质量的标志，也不是目的

如果您想使代码更简单、更高效，这可能包括去掉If条件，特别是当它对源数据进行第二次迭代时，您可以通过各种方式来实现。例如

私有静态可选转换（列表输入）{
最后一个类AbsentValue扩展了RuntimeException{
AbsentValue（）{super（null，null，false，false）；}
}
试一试{
返回可选的.of（input.stream（）.collect（Collectors.toMap(
t1->t1。首先，
t2->t2.second.orelsetrow（AbsentValue:：new），
（第一，下）->第一）；
}捕获（缺席值av）{
返回可选的.empty（）；
}
}

当空选项确实是例外情况时，您可以将通过例外进行标记作为方法契约的一部分，例如

公共静态类AbsentValueException扩展RuntimeException{
}
私有静态映射转换（列表输入）
抛出AbsentValueException{
返回input.stream（）.collect（Collectors.toMap(
t1->t1。首先，
t2->t2.second.orelsetrow（AbsentValueException:：new），
（第一，下）->第一）；
}

@Test（预期值=AbsentValueException.class）
公共图书馆1（{
List input1=new ArrayList（）；
input1.add（新元组（“foo”，可选的第（1）部分）；
input1.add（新元组（“bar”，可选.empty（））；
映射结果1=变换（输入1）；
}
@试验
公共图书馆2（{
List input2=new ArrayList（）；
input2.add（新元组（“foo”，可选的第（1）部分）；
input2.add（新元组（“bar”，可选）（共（2））；
映射结果2=变换（输入2）；
assertEquals（（int）1，（int）result2.get（“foo”）；
assertEquals（（int）2，（int）result2.get（“bar”）；
}

---

更好的做法是，首先不要在元组列表中添加可选项。

“纯函数式编程”本身不一定是质量的标志，也不一定是目的

如果您想使代码更简单和