Java Stream sum() short circuiting

Question

While doing a project I wrote this line, basically it decided whether or not to merge the current node based on how many children there are.

int succNodes = Arrays.stream(children).mapToInt(PRQuadNode::count).sum();
if (succNodes <= bucketingParam) { /* do something */ }

The problem is that succNodes will often be significantly larger than bucketingParam. And there's no point to continue counting if I have already found a large enough sum. What would be the best way to enable the stream to stop early, if I knew I was going to fail the check succNodes <= bucketingParam?

Note: In this case children is always of size 4.

Note 2: PRQuadNode::count is a recursive method, it is not tail recursive.

Answer 1

Actually, Java 9 comes with the takeWhile method, which is a short-circuiting operation of the stream, returning the longest prefix of elements matching the given predicate.

Because the predicate depends on the sum of the previous elements, a wrapper has to be used in order to store the intermediate result. In the example below, I use the AtomicInteger class:

AtomicInteger sum = new AtomicInteger();
Arrays.asList(2, 3, 5, 7, 11, 13, 17).stream()
    .takeWhile(i -> sum.addAndGet(i) < 15)
    .forEach(System.out::println);

Returns:

2
3
5

Answer 2

You cannot short-circuit the stream pipeline with the use of streams alone.

one workaround (with the use of side-effects) would be:

int[] c = new int[1];
boolean r = Arrays.stream(children).noneMatch(e -> (c[0] = c[0] + e.count()) > bucketingParam);
if (r) { /* do something */ }

This accomplishes the task but unfortunately, is not threadsafe (doubt you're ever going to run this in parallel anyway as your source will always have 4 elements).

An imperative approach would be:

int succNodes = 0;
boolean result = true;
for (PRQuadNode p : children) {
    if (succNodes > bucketingParam) {
         result = false;
         break;
    }
    succNodes += p.count();
}

if (result) { /* do something */ }

Answer 3

One cannot do this with stream. However, you can already filter out if it is greater than bucketingParam. If any of them already greater than bucketingParam there's no point in continuing.

if (Arrays.stream(children).mapToInt(PRQuadNode::count)
                           .noneMatch(x -> x > bucketingParam)) {
    int succNodes = Arrays.stream(children).mapToInt(PRQuadNode::count).sum();
}