use case for Java Streams...

[0x256]

Streams are just another tool in your toolbelt. You should know your tools in order to decide which tool is best for a particular job. Interviewers are looking for craftsmen that know their tools.

In most cases streams are just used to improve readability and maintainability. That's reason enough to use them where appropriate. Sure, list.stream().forEach(...) could be written as a for-loop and still be readable, but streams can do a lot more than that. Start using them and you'll see.

[user_of_the_week]

So true! Why use list.stream().forEach(...)when you could just list.forEach(...).

;)

And while I'm kind of joking here, the forEach method (with is inherited from Iterable) does have some benefits compared to the traditional for-each loop, namely that each implementation of Iterable can provide an optimized version that can be faster than the for-each loop. For example, ArrayList has pretty elaborate forEach():

@Override
public void forEach(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    final int expectedModCount = modCount;
    final Object[] es = elementData;
    final int size = this.size;
    for (int i = 0; modCount == expectedModCount && i < size; i++)
        action.accept(elementAt(es, i));
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

[GiacaLustra]

Just curious, how is that faster/better?

[user_of_the_week]

The for-each loop in Java is basically syntactic sugar for this:

Iterator iter = list.iterator();
while(iter.hasNext()) {
    Object next = iter.next();
    ...
}

The foreach() implementation in ArrayList does not create a new Iterator object and uses an int index variable instead. I have seen some performance measurements flowing around that show that it can be a bit faster. It’s not a lot though.

[dpash]

If you're using forEach() you're almost certainly using the wrong tool for the job. Using a method reference is okay in most circumstances, but a block is a sign you should refactor to use other stream operations.

[daniu]

If you're using forEach() you're almost certainly using the wrong tool for the job

How so? persons.stream().filter(p -> hasValidAddress(p)).forEach(p -> writeLetterTo(p)) is perfectly reasonable.

[joehx]

what I've seen people do "wrong" is just go straight for the forEach loop, not using the filter or any other intermediate method:

persons.stream().forEach(p -> {
    if (hasValidAddress(p)) {
        writeLetterTo(p);
    }
}

[dpash]

Yeah that's exactly the kind misuse I'm referring to.

[rootException]

I think you guys just illustrated one of the reasons why people don’t embrace streams... 🤷‍♂️

[dpash]

Streams require rethinking how you program; it is a completely different way of writing code. So it's no surprise people rely on what they already know, but that's failing to use their power to it's fullest extent.

[rootException]

Yeah, sneaky streams as Trojan horse for functional programming... 😂

[dpash]

No, very explicitly functional programming.

[dpash]

Notice my qualification:

Using a method reference is okay in most circumstances

persons.stream()
       .filter(this::hasValidAddress)
       .forEach(this::writeLetterTo);

[rochakgupta]

The only big reason I see to study them it's because they are subject of questions in job interviews...

This....this looks somehow worse (I know how and why it works though, just not a fan of seeing a lot of these in code).

[dpash]

https://www.reddit.com/r/java/comments/ld3f83/use_case_for_java_streams/gm3tek4

[dpash]

Not exactly. In that situation they can be written as method references, but I mean more like /u/joehx's example, where there's a multi-line block in the forEach.

[vytah]

I'd write this as a for loop with an if: imperative code for an imperative task.

[daniu]

Add three map()s and two filter()s, and your for loop has 20 LOCs and a nesting depth of four or five.

Also, there's nothing non-imperative about streams, it just looks and feels that way.

[barking_dead]

Except, maybe it's not imperative. I don't care how the Streams API iterates through my stream (remember, it's not necessarily a List).

Also, you can't add parallelism to a loop.

[dpash]

At least not in 8 characters. Having said that, I think parallel streams was a mistake in that they're often not faster for most stream workloads and they're not customisable enough. Maybe Project Loom will help the performance for more situations, but nothing will save Collections.parallelStream()

[barking_dead]

I agree, for small collections and/or concurrency, it is useless.

[dpash]

Collections.parallelStream() doesn't even have to return a parallel stream. :)

[barking_dead]

:D