从 Java 8 映射操作返回空元素

Question

当输入 Integer 没有输出时，使用 Java 8 流最好的方法来映射 List<Integer> 是什么？

只返回null？但是现在我的输出列表大小将小于我的输入大小......

    List<Integer> input = Arrays.asList(0,1,2,3);
    List<Integer> output = input.stream()
                                .map(i -> { 
                                    Integer out = crazyFunction(i);
                                    if(out == null || out.equals(0))
                                        return null;
                                    return Optional.of(out);
                                    })
                                .collect(Collectors.toList());

Answer 1

我不明白你（以及所有答案）为什么把它弄得这么复杂。您有一个映射操作和一个过滤操作。所以最简单的方法就是一个接一个地应用这些操作。而且除非你的方法已经返回了一个Optional，否则没有必要处理Optional。

input.stream().map(i -> crazyFunction(i))
              .filter(out -> out!=null && !out.equals(0))
              .collect(Collectors.toList());

可以简化为

input.stream().map(context::crazyFunction)
              .filter(out -> out!=null && !out.equals(0))
              .collect(Collectors.toList());

但您似乎有一个更理论的问题，即要生成哪种List，一个带有用于缺少值的占位符，或者一个具有与输入列表不同的大小。

简单的答案是：不要生成列表。 List 本身并不是目的，因此您应该考虑需要此列表（或其内容）的 操作 类型，并将操作权限应用为流的终端操作。然后你就有了答案，因为操作决定了是否应该过滤掉缺失的值或用特殊值表示（以及必须是什么值）。

不同的操作可能会有不同的答案……

Answer 2

将map 调用替换为flatMap。 map 操作为每个输入值生成一个输出值，而flatMap 操作为每个输入值生成任意数量的输出值——包括零。

最直接的方法可能是像这样替换检查：

List<Integer> output = input.stream()
                            .flatMap(i -> { 
                                Integer out = crazyFunction(i);
                                if (out == null || out.equals(0))
                                    return Stream.empty();
                                else
                                    return Stream.of(out);
                                })
                            .collect(Collectors.toList());

进一步的重构可能会更改crazyFunction，使其返回Optional（可能是OptionalInt）。如果您从map 调用它，结果是Stream<OptionalInt>。然后你需要flatMap那个流来删除空的选项：

List<Integer> output = input.stream()
    .map(this::crazyFunctionReturningOptionalInt)
    .flatMap(o -> o.isPresent() ? Stream.of(o.getAsInt()) : Stream.empty())
    .collect(toList());

flatMap 的结果是Stream<Integer>，它将ints 打包，但这没关系，因为您要将它们发送到List。如果您不打算将 int 值装箱为 List，则可以使用以下命令将 Stream<OptionalInt> 转换为 IntStream：

flatMapToInt(o -> o.isPresent() ? IntStream.of(o.getAsInt()) : IntStream.empty())

有关处理选项流的进一步讨论，请参阅this question and its answers。

Answer 3

@Martin Magakian 答案的更简单变体：

List<Integer> input = Arrays.asList(0,1,2,3);
List<Optional<Integer>> output =
  input.stream()
    .map(i -> crazyFunction(i)) // you can also use a method reference here
    .map(Optional::ofNullable) // returns empty optional
                               // if original value is null
    .map(optional -> optional.filter(out -> !out.equals(0))) // return empty optional
                                                           // if captured value is zero
    .collect(Collectors.toList())
;

List<Integer> outputClean =
  output.stream()
    .filter(Optional::isPresent)
    .map(Optional::get)
    .collect(Collectors.toList())
;

Answer 4

您可以将输出包装到 Optional 中，该 Optional 可能包含也可能不包含非空值。
带输出：return Optional.of(out);
无输出：return Optional.<Integer>empty();

您必须换行到一个选项中，因为数组不能包含任何空值。

    List<Integer> input = Arrays.asList(0,1,2,3);
    List<Option<Integer>> output = input.stream()
                                .map(i -> { 
                                    Integer out = crazyFunction(i);
                                    if(out == null || out.equals(0))
                                        return Optional.<Integer>empty();
                                    return Optional.of(out);
                                    })
                                .collect(Collectors.toList());

这将确保input.size() == output.size()。

稍后您可以使用以下方法排除空的 Optional：

    List<Integer> outputClean = output.stream()
                                   .filter(Optional::isPresent)
                                   .map(i -> {
                                           return i.get();
                                        })
                                   .collect(Collectors.toList());