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.

well you should experiment a bit, after some time you get an intuitive understanding of what all that stuff do.
In short: stream() produce a continuous sequence of items (depending on the source, for example an array or collection). You can think of it as an assembly line with stuff proceeding on a treadmill. All those methods are like workers operating on the treadmill.
For example, filter() remove stuff based on some validation rule, think of them as inspectors that discard broken items from the production line. You provide the validation rule. It's in the form of a function that takes the object and return true or false (a Predicate). This method obviously can decrease the amount of items on the "production line".
Map() let you transform objects on the line. It reminds me of those "tunnels" in assembly lines where one thing enter and a different one exit. For example, if you have a stream of String, you can process each item and transform it in the uppercase version of it: map(s -> s.toUppercase()). You provide the transformation logic in the form of a Function, it can really do anything, can even return a different class, so a map() can turn a stream of String into a Stream of List or anything else. It doesn't change the number of items on the stream. Sort() should be easy to undertand, the assembly line analogy kind of breaks here but it simply gives you the same stream but with elements sorted in some order, either default or provided by you (a Comparator).

Just as the assembly line, stream methods can be chained, so that the output of the previous worker is the input of the next worker. You could filter(), then map(), then sort(), etc. The map() will not receive items filtered by the upstream filter(), and the sort() will receive object already tranformed by map().

After all that work, objects can be collected, this is the job things like collect() or forEach() methods and Collectors. Items can be poured in a List (Collectors.toList()), processed right there (forEach), distributed in a Map, partitioned, etc etc (just looks at Collectors for how much choice there is).

IHTH, if you have any specific question feel free to ask