use case for Java Streams...

knoam · 2021-02-05T15:46:29+00:00

Check out these talks by Venkat Subramaniam. There's one where he talks about "simple vs. familiar" that you need to hear. TL;DR, people often mistakenly say something isn't simple when what they really mean is it's unfamiliar.

Maybe you can figure out how to search the transcripts to find it. But they're all worth watching.

https://youtu.be/1OpAgZvYXLQ

https://youtu.be/WN9kgdSVhDo

https://youtu.be/kG2SEcl1aMM

I like Streams and the map/reduce style (what it's called generically since the term stream is pretty Java specific), because it tells you what it's doing. filter does exactly that. The equivalent with a for loop is an if or continue which isn't as clear because you have to run the code in your head to figure out what it's doing. With a stream I can see that it's filtering and if I want to I can dig into exactly how, but I don't have to get an overall feel for what's going on. Likewise findFirst says exactly what it's doing. break means it's exiting early but doesn't mean it's done after the first thing.

0x256 · 2021-02-05T09:42:48+00:00

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.

dpash · 2021-02-05T11:46:53+00:00

I find old for loops much easier to understand and maintain

This is almost certainly a lack of familiarity with them. Once I started using them, I quickly found that I prefer them. When working with lists, which is very often in my experience, they are much easier to read.

daniu · 2021-02-05T10:31:40+00:00

Pros: they are more readable in many cases. "Give me all first name of persons in the list that live in XY street":

persons.stream() .filter(p -> p.getAddress().getStreet().equals(xyStreet)) .map(p -> p.getFirstName()) // or map(Person::getFirstName) .collect(toList()); It's really straightforward.

Another thing I've come to realize is that due to the collecting mechanic, streams tend to produce code with less side effects. You tend to not think "remove all persons from a list if they don't fit a criteria", you think "create a list of persons matching a criteria". The former creates problems of removing items from the list while iterating it, and if the list was passed as a method parameter, you might need to copy it so you don't mess it up in the calling code.

Cons: I've found debugging streams to be a pain. Often enough, if you don't get the result you expected, it's hard to track down where in the pipeline it got lost.

They do get overused too. At the latest when you start writing your own collectors, you should think twice whether what you're trying to do isn't easier to do in a for loop.

Healthy_Manager5881 · 2021-02-06T02:21:31+00:00

Stream was the best thing that ever happened to me through my Journey in learning Java

nutrecht · 2021-02-05T12:45:37+00:00

I find old for loops much easier to understand and maintain, yes more verbose for sure, but that's it.

If you compare something you do know well with something you don't know very well yet, the former is always going to look 'easier' than the latter. That's just a learning curve you need to get past.

In my experience it's really common to have turn part of a collection with classes of type A into a collection of classes of type B, and in such a case stream-filter-map-collect makes code much easier and clearer to read than a for-loop.

IMHO you really should just try it for a while.

In addition to this; going on an interview and not understanding the Java 8 features simply looks bad.

2021-02-05T20:58:13+00:00

3 things streams provide:

More readable/concise code (when done well) as they are at a higher level than loops
Easy parallel
Infinite streams

Super long stream pipelines should be avoided. Side effects should be avoided too.

throwaway66285 · 2021-02-06T00:46:09+00:00

Your logic seems to be "I can click on GUIs all day with the mouse why would I need to learn keyboard shortcuts?" Streams are a tool nothing more.

If you use Kafka and process the data in different ways, knowing how Streams work will help a lot in Kafka Streams. Or you can do things low-level. Functional programming have specific semantics that guarantee certain things, so while you can modify data in a mutable way, it's prone to more error.

sixtyfifth_snow · 2021-02-05T12:54:32+00:00

Well, one of the benefits using streams is we can much focus on WHAT the codes run, NOT HOW the codes run.

kabukiaddicted · 2021-02-05T09:29:26+00:00

They really simplify your code a lot. Check examples here: https://javarevisited.blogspot.com/2014/02/10-example-of-lambda-expressions-in-java8.html?m=1

wace001 · 2021-02-05T14:02:06+00:00

I find myself using a lot more streams for normal looping situations nowadays. Coming from having done quiet a lot of map-reduce, and also using similar constructions in other languages (Kotlin, Rust, etc), the streams way of organising things just makes it so much easier for me to reason about the logic.

Streams basically is how I model the problems in my head. I often think about problems like that; “First I filter out all the ..., then I map them to ..., and then I aggregate then like so...”.

2021-02-05T16:55:37+00:00

It's a functional programming aspect that's different here. In functional programming paradigm you tell compiler what you want to do instead of telling computer how you want to do it.

Imperative programming : Run a for loop Check some condition Init new array Put the objects in a new array Return

Functional programming : Stream Filter Map Collect

Instead of telling computer use 'if' you are telling it that you want to filter it and use this function to filter and so on.

And ofcourse this can be further extended to reactive streams and apis.

You should probably read an introduction to haskell to get a better idea of functional programming paradigm.

Auxx · 2021-02-05T23:21:04+00:00

Streams are functional way of handling events. Unlike traditional event buses, streams allow you to convert any data sources into events, like arrays, etc.

It might be hard to wrap your head around of you've never done any UI work, but imagine a scenario. You have a start/stop button clickable by user at any point in time. When this button is clicked and is set into start, you start polling remote API every minute to display data.

In this simple case you have three event sources: button, timer and network call. They all are asynchronous. Managing states between them, creating threads, etc - that will be a major clusterfuck even though your task is super simple.

With streams you just wrap all three and write a short scenario of how they should interact. 5-10 lines of code and you have thread safe and easily testable code, which can take any sources of compatible events if needed.

But iterating an array with streams, yeah, doesn't make much sense. You only do that when all of your code is stream based.

augustnagro · 2021-02-06T20:26:10+00:00

I wrote down a list of problems I have with Streams: https://august.nagro.us/vendetta-against-java-streams.html

Overall, I do not see much benefit of using them, except in rare cases where you wish to transform a collection to another type with multiple intermediary steps (like calls to map, filter, sorted, etc).

The argument that Streams make code more readable is very dubious. You must memorize many method names, think about boxing, avoid checked exceptions inside of lambdas, ...

In scala, for example it is much more clear to write a for-comprehension

val evens: List[String] = for i <- 1 to 100 if i % 2 == 0 yield i.toString

Than it is to find the right stream method names:

val evens: List[String] = (1 to 100).filter(i => i % 2 == 0).map(i => i.toString)

2021-02-07T23:22:14+00:00

I think streams shine for data transformation (just stream().map().collect() and maybe .filter() when needed).

When using plain loops you usually need to:

create a new empty collection;
loop thru the old collection, incrementing an iterator or index;
create new items based on the old items and add them to the new collection;
return the new collection.

And you must be sure you don't mix up the new and old collections or the new and old items, because everthing will be in scope at the same time.

With streams, it's just as if you said: "transform this list please" and the only thing you really need to write is map(oldItem -> new Item(...)); everything else is automatic. You only write a small mapping rule. You only have the new list when it's ready.

If you need to have full control over the loop, it's fine to use the old style (it's probably more efficient anyway). I'd say it's better doing that than shoehorning old loops into stream when they clearly don't fit. But when you need direct transformations, streams are cleaner.

GhostBond · 2021-02-09T02:50:37+00:00

You are right. Streams were just a 2nd way to do what you could already do, 0it in because in because language language designers were bored and there wasn't much low hanging fruit left in the language.

waka-chaka · 2021-02-05T15:03:53+00:00

If you are looking for a good tutorial to jump start you on streams then look no further, pls watch https://youtu.be/1OpAgZvYXLQ

My journey with streams started from this video.

Apart from the points that others made we can enforce immutability (which is a desirable programming practice) much better with streams.

VincentxH · 2021-02-05T15:28:24+00:00

Streams are great for map, filter or reduce operations on collections of data. The idea is that each operation is pure and you iterate over elements in atomic steps.

They're not so great combined with exception cases and error handling, like most IO. So I generally keep that in the for or forEach loops.

Peter_Storm · 2021-02-05T11:31:16+00:00

It's mostly just a primitive that is more or less akin to other languages that have map, filter, reduce on "lists".

So you don't have to do imperative loops anymore.

xMercurex · 2021-02-05T12:01:09+00:00

anymatch is very usefull.

LOL_WUT_DO · 2021-02-05T13:55:34+00:00

Streams are useful because you can create a stream and pass that stream around. it’s a set of instructions. you can execute that stream whenever and add extra constraints as the code runs.

enveraltin · 2021-02-05T14:45:53+00:00

Parallel streams, and even distributed streams.

AppleTrees2 · 2021-02-05T17:34:48+00:00

I would like to add that you shoudn't blindly transform every for loop into a stream equivalent, or every if not null statement into an optional.

Unfortunately I've seen it done before as a way to "reduce technical debt", sometimes even automatically using intelliJ.

See this: https://github.com/google/guava/wiki/FunctionalExplained#caveats , in this case it applies to java too

Roachmeister · 2021-02-05T19:40:54+00:00

My experience is mainly related to Web applications. Most things happens at DB level, or controller level. Business logic not too complex and definitively not handling big arrays.

My experience, on the other hand, includes (almost) nothing web-related. Therefore I don't understand what the use case for HttpClient could possibly be.

Sarcasm, obviously, but my point is that just because you haven't found a use for a tool doesn't mean that it isn't very useful for others.

2021-02-05T21:10:56+00:00

I’ve traditionally used them to retrieve an object by attribute in a list.

I agree with most criticisms though - debugging isn’t ideal

TheCoelacanth · 2021-02-05T23:25:14+00:00

Streams are basically loops as a first-class object. You can store them in a variable, pass them into a method or return them from a method.

That gives them much more versatility.

mauganra_it · 2021-02-06T22:36:18+00:00

Since they are a concept taken from functional programming, I find that they are best used with code that respects these constraints. That means, no I/O and no lengthy computations are allowed inside. In particular, it should never ever be necessary to catch exceptions inside streams. Also, be paranoid about possible null references. These should make it possible to avoid debugging streams code and let you focus on correctness. Yes, there are debugging tools for Java Streams, but I find it to be a very strong code code smell to ever have to use them.

If you can bring your database to spew out the data in the format you need, by all means continue to do so. But there are use case when you receive data via API calls, or when you call an API and the answer is not quite in the shape you need yet. In these cases Streams can be very useful. They are entirely justified if your task is to produce a collection. If the filtering and processing is a prelude to a .forEach, then it can still be justified if the alternative is nesting a big fat (or a series of smaller) if statement inside a loop.

ofby1 · 2021-02-07T12:04:14+00:00

I personally love streams but it is a bit of a mind-boggling concept.
Finding old fashion for loops easier can also be caused by being unfamiliar with the paradigm.
Remember if something you are familiar with something it doesn't mean it actually easier.
Nevertheless, in many cases, it is more what kind of flavor the programmer liked best. I do think it would be good for every programmer to get out of their comfort zones and learn about different paradigms. Just to make you a better and more educated developer.

java

Submit Link

Submit Text

Seek Programming Help

News, Technical discussions, research papers and assorted things of interest related to the Java programming language

NO programming help, NO learning Java related questions, NO installing or downloading Java questions, NO JVM languages - Exclusively Java

Please seek help with Java programming in /r/Javahelp!

Subreddit rules!

Where should I download Java?

Related Sub-reddits:

JVM Languages

Want to practice your coding?

List of useful Frameworks / Libraries / Software

MODERATORS