最近,在使用Java 8流时,在使用以下测试用例时,我遇到了一个关于reduce操作的NullPointerException:

private static final BinaryOperator<Integer> sum = (a, b) -> {
    if (a == null) return b;
    if (b == null) return a;
    return Integer.sum(a, b);
};

List<Integer> s = new ArrayList<>();
s.add(null);
s.add(null);
s.add(null);

Integer i = s.stream().reduce(sum).orElse(null);
// throws NPE

Integer i = s.stream().reduce(sum).orElse(2);
// throws NPE

Integer i = s.stream().reduce(null,(a, b)->null);
// returns a value i.e null

或者:
Integer i = s.stream().filter(Objects::nonNull).reduce(Integer::sum).orElse(null);
// returns a value i.e null

在检查了reduce操作后,我遇到了执行reduce操作的此类:
class ReducingSink implements AccumulatingSink<T, Optional<T>, ReducingSink> {
    private boolean empty;
    private T state;

    public void begin(long size) {
        empty = true;
        state = null;
    }

    @Override
    public void accept(T t) {
        if (empty) {
            empty = false;
            state = t;
        } else {
            state = operator.apply(state, t);
        }
    }

    @Override
    public Optional<T> get() {
        return empty ? Optional.empty() : Optional.of(state);
    }

    @Override
    public void combine(ReducingSink other) {
        if (!other.empty)
            accept(other.state);
    }
}

在上面的代码中,您看到如果boolean get()为false,则empty方法返回一个可选值,在我的情况下,该值为false,但state为null,因此Optional.of(null)抛出了NullPointerException。就我而言,我有一个允许null的二进制运算符。

所以我认为代码
return empty ? Optional.empty() : Optional.of(state);

应该更改为
return empty || state == null ? Optional.empty() : Optional.of(state);

作为我的二进制运算符(具有减少的任务),可以使用null

最佳答案

我真的不能说出为什么必须使用null,这似乎是一个不好的主意。而且,如您所见,您不能使用null作为输入来reduce。您可以构建自己的自定义Collector(不能构建自己的Reducer)。

您所拥有的:

 Double result = s.stream()
         .filter(Objects::nonNull)
         .reduce(Double::sum)
         .orElse(null);

完美吗顺便说一句。获得空结果的唯一方法是输入中的所有元素都为空时,因此首先对它们进行过滤是必经之路。出于乐趣,我决定编写一个自定义收集器(我猜不出为什么,我想那会很有趣)
 Double result = s.stream()
          .parallel()
          .collect(
                () -> new Double[] { null },
                (left, right) -> {
                    if (right != null) {
                       if (left[0] != null) {
                           left[0] = right + left[0];
                       } else {
                            left[0] = right;
                       }
                    }
                },
                (left, right) -> {
                   if (right[0] != null) {
                        if (left[0] != null) {
                            left[0] = right[0] + left[0];
                        } else {
                             left[0] = right[0];
                        }
                }})[0];

如果需要,您可以将其放入类本身:
 class NullableCollector implements Collector<Double, Double[], Double> {

    @Override
    public BiConsumer<Double[], Double> accumulator() {
        return (left, right) -> {
            if (right != null) {
                if (left[0] != null) {
                    left[0] = right + left[0];
                } else {
                    left[0] = right;
                }
            }
        };
    }

    @Override
    public Set<Characteristics> characteristics() {
        return EnumSet.noneOf(Characteristics.class);
    }

    @Override
    public BinaryOperator<Double[]> combiner() {
        return (left, right) -> {
            if (right[0] != null) {
                if (left[0] != null) {
                    left[0] = right[0] + left[0];
                } else {
                    left[0] = right[0];
                }
            }
            return left;
        };
    }

    @Override
    public Function<Double[], Double> finisher() {
        return (array) -> array[0];
    }

    @Override
    public Supplier<Double[]> supplier() {
        return () -> new Double[] { null };
    }

}

10-06 05:29
查看更多