Master Java Lambdas: From Basics to Advanced Stream Tricks

What is a Lambda?

We know that a Java variable can be assigned a "value". If we want to assign a block of code to a variable, we need a way to do it.

Before Java 8 this was impossible, but Java 8 introduced Lambda expressions that make it feasible.

To make the assignment more elegant we can remove unnecessary declarations.

The resulting code block assigned to a variable is a Lambda expression.

In Java 8 every Lambda has a type that is a functional interface—an interface with a single abstract method.

Marking the interface with @FunctionalInterface prevents adding extra abstract methods.

Thus we obtain a complete Lambda declaration.

What is the purpose of Lambda expressions?

The most direct benefit is dramatically more concise code.

Lambda can be passed directly as a method argument, eliminating the need for a separate concrete class implementation.

In cases where an interface implementation is needed only once, Lambda keeps the code clean compared to the verbose Java 7 approach.

Lambda with FunctionalInterface library, forEach, stream() and method references

Assume a Person class and a List<Person> are given.

Goal: print the first names of all persons whose last name starts with "Z".

Original Lambda version defines two functional interfaces and a static helper method.

We can simplify by using the standard java.util.function interfaces ( Predicate, Consumer).

Step 1: replace custom interfaces with the functional‑interface library.

Step 2: replace explicit loops with Iterable.forEach(), which accepts a Consumer.

Step 3: drop the static helper and use the Stream API directly; stream() methods also accept Predicate and Consumer.

If we want to print the whole object, we can replace the lambda p -> System.out.println(p) with a method reference System.out::println.

Final concise version:

Lambda with Optional<T> for elegant null handling

Assume a Person object wrapped in an Optional<Person>.

Without Lambda, Optional does not simplify null checks.

When combined with Lambda, Optional shines.

Four common null‑handling patterns are compared:

Case 1 – Execute if present.

Case 2 – Return value or fallback.

Case 3 – Generate value when absent.

Case 4 – Avoid deep nested null checks.

These examples show that Optional<T> together with Lambda reduces boilerplate and makes null‑handling clear and concise.

Further topics include handling exceptions in Lambdas and using Lambdas for parallel processing.