在java 8流中使用.peek（）

Question

I am using .peek() in my stream but it is frowned upon, sadly I can't find a solution.

Simplified version:

static boolean fooAddTester(int size) {
    Foo foo = new foo(); //data structure

    return IntStream.range(0, size).
            .peek(i -> synchronized(r){foo.add(i)})
            .allMatch(e -> foo.isLegal());
}

what I need to do is to iterate over the IntStream and to check after every insert if the foo data structure is legal. This is logically equivalent to:

static boolean fooAddTester(int size) {
    Foo foo = new foo(); //data structure

    for(int i=0; i<size; i++){
        foo.add(i);
        if(!foo.isLegal())
            return false;
    return true;
}

However it is more complex and I'm trying to use streams to simplify and learn.

A way to do the same without using .peek() is this: which does work - but I'm just "moving" the problem to .allMatch() :

return IntStream.range(0, size).
            .allMatch(i -> {
                 synchronized(r){foo.add(i)};
                 foo.isLegal();
             )};

My problem is very similar to this question , the diffrence is that I am checking every time so the solutions aren't working.

So my questions are:

• Is .peek() really only to debugging or can I use it in this manner?
• Is there any better solution?
• Should I use my second solution?

I'm looking for a correct solution, not a working solution, all of those codes are already working.

Answer 1

the documentation of Stream#peek has mentioned as below, and mainly is not absolutely :

This method exists mainly to support debugging, where you want to see the elements as they flow past a certain point in a pipeline

@Holger has answered this question absolutely:

the most useful thing you can do with peek is to find out whether a stream element has been processed.

and some side-effects he has also pointed it out in his answer, the peek operation depends on which terminal operation was invoked. so when using peek internally you should be carefully.

so the correctly way is just using for-each loop, since Stream#collect doesn't support short-circuiting operation .

the optional way is using peek because you can control the stream by yourself. and you need to remove the synchornized block, it is unnecessary here.

return IntStream.range(0, size).peek(foo::add).allMatch(__ -> Foo.isLegal(foo));

Answer 2

I can think of only a single way to do it if you really want to use other stream operations before your logic, but I'm not really a big fan of it...

 boolean result = true;
    try {
        IntStream.range(0, 10)
                .forEachOrdered(x -> {
                    foo.add(x);
                    if (!Foo.isLegal(foo)) {
                        throw new RuntimeException("just because");
                    }
                });
    } catch (RuntimeException re) {
        result = false;
    }

    System.out.println(result);

Obviously you need to replace RuntimeException with some kind of your exception.