Functional & Reactive programming in Java : Modern Style

Learn why to bother with functional programming as another paradigm, embrace pure functions, and write concise, side-effect free code that tells the program what to do.

Explore the foundation of functional and reactive programming by examining lambdas and functional interfaces, how they work under the hood, and the shift from imperative to declarative styles.

Discover how lambda expressions simplify Java threading by turning anonymous inner classes into concise lambdas, leveraging functional interfaces with a single abstract method run, enabled by Java 8 type inference.

Explore how lambda expressions rely on functional interfaces, defined as interfaces with a single abstract method, and see how to supply on-the-fly behavior using lambdas and runnable examples.

See how Java implements lambdas under the hood by using runtime invoke dynamic support and replacing anonymous inner classes, reducing class files and improving memory usage.

Compare imperative and declarative programming in Java, highlighting how lambdas and streams enable declarative style through filter and reduce, with benefits like readability and thread safety.

Learn how Java 8 introduces lambdas and functional interfaces, enabling first class functions and backward compatibility with anonymous classes. Explore invoke dynamic and the shift from imperative to functional style.

Explore how Java uses functional interfaces and lambdas to treat functions as first-class citizens, covering lambda syntax, parameters, return types, and multi-line expressions through hands-on practice.

Create a lambda for a method with no parameters and no return type. Use an empty parentheses, an arrow, and a single statement that prints john.

transform a parameterized method into a lambda using arrow syntax and type inference, printing the sum or product of two arguments via a reusable math operation.

Practice lambda 3 demonstrates creating a concise lambda for a string argument with a return type, using type inference, a single-statement body, and omitting explicit return and modifiers.

Learn to convert multi-statement logic into Java lambdas, covering length extraction and printing the length, type inference, arrow placement, multi-line bodies with braces, and when to use return.

Review how to write lambdas for functions with no parameter, with parameters, or with a return type, including multi-line forms. Recognize lambdas as the main building block of functional programming.

Set up the section agenda and explore pre-existing java functional interfaces for writing lambdas. Focus on predicate, consumer, function, and supplier, plus related interfaces.

Explore predefined functional interfaces in java 8 and beyond, within java.util.function, enabling reusable signatures for lambdas through predicate, consumer, function, supplier, unary and binary operators, and their primitive specializations.

Explore functional interfaces with generic syntax, define type parameters t and r, and implement lambdas that take a string and return a string or integer, such as substring and length.

Explore how to use a predicate to test conditions and filter lists of strings, removing empty entries and supporting generic and lambda-based implementations.

Learn how the consumer functional interface consumes a value of type t using the accept method and returns nothing, with examples printing list elements via a generic print elements method.

Explore the supplier functional interface from the function package, which defines a get method that returns a value with no input, demonstrated using string suppliers and random numbers.

Explore the Java function interface for transformation, using generics and lambdas to map a list of strings to their lengths, with a generic map method and apply.

Learn unary operator in Java by extending the function interface to return the same type and map a list by applying the operator, multiplying elements by 100.

Explain the BiFunction interface in Java, which takes two inputs and returns a result via apply, with examples of string concatenation and string length.

Learn binary operator as a specialized bi function that applies to two operands of the same type and returns a value of that type, illustrated by string concatenation.

Reinforce the four foundational functional interfaces in Java, predicate, consumer, function, and supplier, and their custom declarations, plus specialized unary and binary operators and primitive versions to reduce boxing costs.

Explore method references and constructor references in Java, enabling existing methods or constructors to be used as behavior for functional interfaces like predicate, function, consumer, and supplier.

Explore replacing lambdas with method references via the double colon operator, covering instance methods of existing objects, static methods, instance methods on input objects, and constructors.

Explore constructor references and method references in Java functional programming, using the double colon syntax to create objects and simplify threading with runnable tasks.

Explore how to write equivalent method references to lambdas, including static, instance, arbitrary object, and constructor references, with the double colon syntax.

Explore the dangers of null and the null pointer exception, and why Java introduced optional. Then define optional, its benefits, creation, value retrieval, and key methods.

Explore why null references trigger null pointer exceptions and how defensive checks burden code, then discover safer models like Groovy’s safe navigation, Haskell’s maybe, and Scala’s option.

Learn how optional helps prevent null pointer exceptions by wrapping values in an optional, with creation methods off, empty, and nullable, and how optional is immutable and may cost performance.

Explore how to retrieve values from Optional in Java, highlighting the risks of Optional.get and safer alternatives like isPresent, orElse, orElseGet, and orElseThrow.

Explore map, filter, and flatMap operations on optional values, transforming present values, applying a predicate, and chaining with orElse. See how flatMap handles mappers that return options and preserves empties.

Explore additional optional operations in Java, including ifPresent, ifPresent orElse, stream, or, equals, and hashCode, with examples showing actions, streams, and equality checks.

Learn how to handle null dangers by wrapping potentially null values in an optional. Unwrap values from the optional and apply operations like filter and map for real life use.

Explore functional programming as a paradigm that uses first-class, pure, and higher-order functions with referential transparency, plus chaining, composition, closures, and currying, and blends with object-oriented and procedural styles.

Present functional programming as a paradigm of pure mathematical functions that avoid state and mutable data, contrasting it with imperative and object-oriented styles and highlighting lambda calculus and lambda expressions.

Introduce the core concepts of functional programming—functions as first class citizens, pure functions, and higher order functions—along with no side effects and referential transparency for upcoming study.

Explore how functions become first class citizens in Java, enabling passing, returning, and storing them as values in data structures within functional programming.

Explore pure functions in functional programming, which depend only on input and yield deterministic results. Learn they have no side effects, enabling easy reasoning and safer multi-threaded code.

Explore higher order functions in Java by building a factory that produces and configures items using lambdas and functional interfaces like producer, configurator, and factory.

Explore referential transparency, the principle that a function call can be replaced by its value without changing results, and how pure functions enable easier reasoning, testing, and refactoring.

Discover standard functional programming techniques such as functional chaining, functional composition, closures, currying, lazy evaluation, and tail call optimization to write better functional code in Java.

Explore techniques to extract functional behavior from any language, including function chaining and functional composition, to design an API in a functional way, enabled by Java 9 default methods.

Explore function and method chaining in Java by building a custom consumer, using a default thenAccept method and requireNonNull to enforce non null next.

Learn how functional composition reverses the order of execution compared to chaining, using a compose method to combine functions that compute a square's side from its area.

Explore closures in Java, where a function refers to free variables in its lexical context, captured by lambdas, with final or effectively final constraints.

Explore currying by converting a multi-parameter function into a chain of single-argument functions, enabling partial application and reusable interfaces to sum values step by step.

Explore lazy evaluation as a strategy that delays expression computation until value is needed. See how lambdas are lazily evaluated and how a supplier enables lazy initialization of heavyweight objects.

Compare regular recursion and tail recursion in factorial calculation, using an accumulator and base condition; Java lacks tail call optimization, so prefer iteration to avoid stack overflow.

Explore functional programming concepts—functions as first-class citizens, pure functions with no side effects, higher-order functions, and referential transparency—apply chaining, composition, closures, lazy evaluation, and tail-call optimization to write functional apis.

Explore classical gang of four design patterns and fluent interfaces, plus iterator, strategy, decorator, command, factory, and builder patterns, implemented in a functional way.

Explore the iterator design pattern, a behavioral approach that accesses container elements without exposing internal structure, enabling consistent traversal across lists, sets, and other collections using functional and lambda-based styles.

Explore the strategy design pattern as a behavioral approach to select algorithms at runtime, illustrated with symbol and price filters on stock data using lambdas and predicates in Java 8.

Modify an object's behavior at runtime with the decorator design pattern. Explore a functional Java 8 approach using a burger to add veggies and cheese as decorations.

Learn fluent interfaces and method chaining to create readable, flowing code, using an order example that returns the order after add and deliver and supports chained calls.

Practice the factory design pattern to create flooring objects—wooden, concrete, or cork—via a factory method that selects the implementation based on temperature, using a supplier for a functional approach.

explore how the builder design pattern provides flexibility in object creation and immutability after creation, illustrated with string builder, string buffer, and a mobile example implemented with a builder.

Encapsulate a request as an object with the command design pattern, enabling the invoker to execute commands. Use lambdas after Java 8 to replace concrete commands in the invoker.

Explore implementing key design patterns in a functional Java style, including iterator, strategy, decorator, fluent interfaces, command, and factory and builder patterns.

Discover how Java 8 streams enable functional and declarative data processing with the stream API, lazy evaluation, and operations like map, filter, reduce, and parallel streams.

Learn how streams in Java enable declarative, concise data processing by filtering books by genre and rating, and collecting results with Collectors.toList, including parallel streams.

Explore how to map a book collection into a stream, filter horror books with rating above three, and collect the results into a list using a functional pipeline.

Explore the stream pipeline by detailing a source, intermediate operations like filters, and a terminal operation such as collect, including side effects.

Explore how streams are not data containers by building and combining stream pipelines to filter horror and romance books, illustrating immutability, one-time traversal, and terminal collect.

Explore the filter method in Java streams by applying a predicate to each element, producing a stream of elements that pass, such as filtering even numbers and collecting results.

Explore map operations in streams by mapping each element with a mapper function to new values, such as multiplying by 25 and extracting book names, while avoiding state changes.

Apply the reduce operation on streams to produce a single value using an identity and a binary accumulator, illustrated by summing elements.

Demonstrate that streams are lazy, as intermediate operations like filter, map, and reduce delay work until a terminal operation such as collect triggers the pipeline.

Explore Java's primitive streams—IntStream, LongStream, and DoubleStream—and map ratings to a primitive stream for average calculations. Learn to create primitive streams and understand boxing versus unboxing.

Explore numeric streams in Java's functional style, using primitive stream methods like sum, max, min, average, and summaryStatistics, and learn how primitive optionals handle empty streams.

Learn to create bounded streams in Java from collections and maps using entry set, key set, and values, via the of method, Arrays.stream, or a builder.

Explore infinite streams in Java by using iterate with a seed and unary operator, and generate with a supplier to produce endless values, or random numbers, plus limiting when needed.

Flatten a stream of streams, like a and b, into a stream of strings with flatMap and the identity mapper. Read lines from a file, split into words, and collect.

Learn how parallel streams leverage multi-core processing to speed data work. The lecture covers stateless, associative operations and when parallelism helps or hurts.

Differentiate stateless and stateful operations in Java streams, noting skip and limit are stateful. Explain why parallel streams are discouraged for these operations and how results are collected.

Explore the common fork join pool for parallel stream operations, adjust parallelism with system properties or custom pools, and decide thread counts based on cpu bound versus io bound workloads.

Explore Java streams, the stream API, and the pipeline of source, intermediate, and terminal operations, with lazy evaluation, streams not containers, and map, filter, reduce, flatMap, and primitive streams.