• Format — 2,100+ free MCQs with instant explanations after every wrong answer.
• Duration — about 24.3 hours of focused practice; most learners finish over 5–7 weeks at 45–60 minutes a day.
• Level — intermediate. Assumes Java fundamentals (OOP, generics, collections, exceptions). No prior functional-programming experience required.
• Cost — free, with a free completion certificate.
• Audience — working Java developers modernising their codebases, candidates preparing for product-company Java interviews where Streams come up in every round, backend engineers replacing loops with declarative pipelines, and engineering students prepping for placements.
• Recommended before this — Java Fundamentals (covers the language ground this one assumes).
• Companion course — Java Concurrency & Multithreading for the threading model parallel streams build on.

Three audiences specifically. First, working Java developers who can write a basic stream().filter().collect(toList()) but freeze when an interviewer asks about flatMap versus map, when a parallel stream is wrong, or how a downstream collector composes in groupingBy. Second, candidates preparing for Java interviews at product companies — every senior interview now includes one or two Streams output-prediction or pattern-selection questions, and getting them wrong is a clean disqualifier. Third, backend engineers rewriting old imperative pipelines into declarative ones, where picking the right Collector and avoiding the wrong reducer is the difference between code that scales and code that recomputes intermediate state.

This course is not a Java starter. It assumes you know OOP, generics, and the Collections framework — Stream pipelines start from Collections and lean on generics for every operation. Work through Java Fundamentals first if you do not yet have that grounding.

Functional foundations — the building blocks

• Introduction to Functional Programming in Java — functional programming concepts (immutability, pure functions, higher-order functions) and what the Java 8 release actually changed about the language.
• Lambda Expressions — lambda syntax variants, the effectively-final rule for captured variables, closure semantics, and lambdas in practice (event handlers, comparators, Stream operations).
• Functional Interfaces — the core interfaces (Function, Predicate, Consumer, Supplier, BiFunction, UnaryOperator, BinaryOperator), composition with andThen / compose / negate, and how to write your own.
• Method References — the four types (static, bound, unbound, constructor), when each beats an equivalent lambda, and the surprising places method references silently change semantics.
• Optional — Optional basics, chaining with map / flatMap / filter / orElse / orElseGet, and the pitfalls (null returns, premature .get(), Optional in entity fields) that defeat the abstraction.

Streams API — the entire pipeline

• Stream Creation & Pipeline — creating streams from collections, arrays, IO, generators, and infinite sources; how the pipeline lazily defers until a terminal operation; stream characteristics (ORDERED, DISTINCT, SIZED, SORTED).
• Intermediate Operations — filter, map, flatMap, sorted, distinct, limit, skip, peek; the patterns each replaces and the cases where one is clearer than another.
• Terminal Operations — anyMatch / allMatch / noneMatch, findFirst / findAny, reduce, count, sum / min / max / average, forEach; when reduce is the right primitive and when a Collector is.
• Collectors — toList, toMap, toSet; groupingBy with downstream collectors for multi-level aggregation; partitioningBy; joining; counting and summarising statistics.

Performance and production patterns

• Parallel Streams & Primitive Streams — when parallelStream() actually speeds work up (and the larger set of cases where it does not), IntStream / LongStream / DoubleStream for boxing-free numeric work, and stream-performance pitfalls (boxing in hot paths, stateful lambdas, ordering costs).
• Java Streams & FP in Practice — concept comparisons (stream vs loop; map vs flatMap; reduce vs collect; parallel vs sequential), pattern selection (which Collector for which problem), and Streams in real production code.

One of the most-asked Java code-review questions and one this course gives you a real answer to. Streams shine when the operation is a data transformation that maps cleanly to map / filter / collect — the code reads like the intent, allocations are predictable, and parallelism is one method call away. Loops shine when the operation is mostly side-effects (mutating an external state, calling void methods, breaking out early on a complex condition), when you need access to the index, or when the work is small enough that the stream overhead dominates.

The course works through this with output-prediction MCQs (does this stream produce the same result as the equivalent loop?), pattern questions (rewrite this 20-line loop as a stream in three lines), and trap questions (this 'cleaner' stream rewrite has a sneaky off-by-one because of the order of distinct() and sorted()). By the time you finish the In Practice topic, the stream-or-loop decision is reflex.

Active recall on real pipelines, not skimming the Stream API Javadoc. Most developers can read a stream when shown one, but the test is different — can you produce the right pipeline cold when given a transformation, or pick the right Collector under interview pressure? MCQ practice forces production every question. The 2,188 questions in this course are spread across the 11 topics so every concept (map vs flatMap, reduce vs collect, when parallel helps, how groupingBy composes) comes back in different framings until pattern selection is automatic.

Spacing matters too. 45–60 minutes a day for 5–7 weeks beats one cram weekend, because the Stream API has enough small rules (laziness, statelessness, ordering guarantees, parallel-safety) that each one only sticks after multiple rephrasings.

One question at a time. You read a snippet (often a 5–15 line stream pipeline), pick the option matching the resulting list, map, or thrown exception, and submit. Wrong answers trigger an explanation that walks through the pipeline step by step — the intermediate states, the laziness shortcut that made one operation never fire, the Collector's downstream chain, the parallel-stream ordering that broke the result.

The Abekus AI guide watches which topics you keep getting wrong and surfaces them more often. If you nail terminal operations but keep mis-predicting groupingBy with downstream collectors, the next session leans on Collectors. The certificate is gated on completing every top-level topic, so the depth signal is honest.

Plan on roughly 24.3 hours of focused practice. The math: 2,188 active questions × ~40 seconds per question (reading the pipeline, picking an answer, skimming the explanation when wrong) = ~1,460 minutes = ~24.3 hours.

Most learners spread that across 5–7 weeks at 45–60 minutes a day. Some compress it into two long weekends; that works for refresh mode but retention is weaker. Trust the spacing — Collector composition, parallel-stream pitfalls, and Optional chaining patterns only stick after the same trap has been rephrased multiple times.

This course assumes Java Fundamentals — OOP, generics, collections. If you have not done Fundamentals yet, do that first and come back. After Streams, the natural progression in the Java Mastery track is Java Concurrency & Multithreading — parallel streams use the common ForkJoinPool, and a real understanding of that thread pool is what makes parallel-stream decisions sharp.

For interview-bound candidates, Java Interview Mastery includes a Modern Java topic that revisits Streams and lambdas as trap questions — a useful complement after this course. For learners curious about functional programming as a paradigm, Python's comprehensions and itertools cover similar ground from a different syntax, and seeing both sharpens intuition for either.