Check Effective Java. It has a really good chapter about abusing streams. More on reddit.com

There are two kinds of streams in Java - Input/Output streams, and Java8 streams. Since you don’t specify, I’ll try to explain both of them. I/O Streams: These are sequences of bytes that you can read from (InputStream and its subclasses) or write to (OutputStream and its subclasses). They’re not very interesting, for three reasons: They’re mostly just Java’s wrapper for file handles, which function exactly like the corresponding I/O constructs in every other programming language. They’ve been mostly supplanted by Reader and Writer, which do essentially the same thing only with characters rather than bytes. You can have I/O streams of objects, too; they’re basically just serializers or deserializers on top of output or input streams. The main reason is that they’re passive. The only thing you can do with a stream is read from it or write to it, or if it’s an input stream test to see whether it’s empty. Java 8 Streams: are something new (to Java — they’ve been around for a long time in functional programming languages), and much more interesting. Java 8 streams are basically a generalization of lists: they are sequences of objects; the difference is in how you use them. Suppose, for example that you have a list of Person objects, and you want to make a list of all the pets belonging to people over 35 years old. In Java 7, you would do it like this: List List pets = new ArrayList<>(); for (Person p : people) { if (p.getAge() > 35) { pets.add(p.getPet()); } } In Java8, you can do this: List pets = people.stream() . filter((p) -> p.getAge() > 35) . map(Person::getPet) . collect(Collectors.toList()); Instead of operating on elements of the list, you’re telling the stream to apply functions to itself. Everything knows its input and output class, so you don’t have to declare any intermediate results. The result is something that’s a lot more readable, and potentially more efficient. That’s the other cool thing about streams: if the functions you’re mapping with don’t have side effects, you can operate on elements in parallel and splice them all back together at the end. You basically get map/reduce for free. Java isn’t anywhere near the best language for functional programming — Scala, which runs in the JVM and can be mixed with Java, is better. Haskell is better still. But if you’re stuck using Java it’s a godsend. Source: https://www.quora.com/What-is-stream-in-java More on reddit.com

Read every section here -> https://dev.java/learn/api/streams/ A couple days later, read them all again. You’ll be working with streams very comfortably after that. More on reddit.com

My take is "Functional Programming Support". Using lambdas and passing them around as any other object is the basic tenet of using functions as your unit of logic. FP allow for lots of lazy evaluation, recycling stuff, do parallel stuff, and immutability starts as a burden but one day it saves you from your own mistakes. I guees it took that oong because Java was the Object Language and if you wanted FP on the JVM, there was Scala and Clojure. But it was a step in the right direction to allow for mixing programming paradigms in Java. I really enjoy doing OO for organising code and managing behaviour, and implementing basic logic in FP. And I can't stress enough how the declarative nature of FP is so much easier to read and maintain than imperative code. More on reddit.com