Lambda Expressions Deep Dive

Lambdas let you pass behaviour as a value. By the end you'll write instead of a five-line anonymous class, and wire up the whole java.util.function toolkit with confidence.

Learn Lambda Expressions Deep Dive in our free Java course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick…

Part of the free Java course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

You should be comfortable with interfaces and anonymous classes . A lambda is just a shorthand way to implement an interface that has a single method — so those two ideas are the foundation everything here is built on.

Imagine you run a kitchen. Sometimes you don't want to do a task yourself — you want to hand a coworker a quick instruction: "slice these", "throw out anything mouldy", "fetch me a clean plate".

💡 Analogy: A lambda is a sticky note with instructions. Before Java 8 you had to write a whole formal letter (an anonymous class) just to say "sort by price". A lambda is the scribbled note instead: . The method you hand it to (like sort or forEach ) reads the note and follows it. A functional interface is simply the kind of note the recipient accepts — one with a single, clear instruction on it.

A lambda has two parts split by an arrow: parameters body . The left side names the inputs; the right side is what to do with them. If the body is a single expression, its value is returned automatically — no return , no braces.

A lambda doesn't exist on its own — it implements a functional interface : an interface with exactly one abstract method (often called the SAM, for Single Abstract Method ). The annotation @FunctionalInterface is optional, but adding it tells the compiler to fail the build if anyone ever adds a second abstract method — a useful safety net.

You rarely need to write your own functional interface. Java ships with a small set in java.util.function that covers almost every shape of "a bit of behaviour". Learn these five and you can read most modern Java:

Notice the method name changes per interface: you call .apply() on a Function , .test() on a Predicate , .accept() on a Consumer , and .get() on a Supplier . The example below uses all five.

Fill in the two blanks so the Predicate and the Function behave correctly. Run it and check your output against the expected lines in the comments.

When a lambda does nothing but call one existing method, you can replace it with a method reference using :: . It's shorter and often clearer. There are four kinds:

Lambdas can also capture local variables from the surrounding method — but only ones that are effectively final : assigned exactly once and never changed afterwards. You don't have to write the final keyword; the variable just has to behave as if it were final.

Replace the lambdas with the two method references described in the comments. Method references read more cleanly than the equivalent x ... lambda.

Before lambdas, you implemented a single-method interface with an anonymous class — many lines of ceremony for one line of logic. A lambda collapses all of that:

They are not identical, though. The differences that matter:

Rule of thumb: reach for a lambda for single-method behaviour; fall back to an anonymous class only when you need fields, multiple methods, or its own this .

No fill-in-the-blanks this time — just a comment outline. Build a Predicate that captures a threshold and use it to filter a stream. The expected output is in the comments so you can self-check.

💡 Prefer method references when a lambda just forwards to a method: Object::toString beats x x.toString() for readability.

💡 Compose predicates for readable filters: isAdult.and(isActive) and isEven.negate() read like English and stay reusable.

💡 Name your behaviour by extracting a long lambda into a method — your stream pipeline then reads as a list of verbs.

You can now write lambdas, recognise the five core functional interfaces, swap in method references, capture variables safely, and explain how a lambda differs from an anonymous class — including the this trap.

Next up: Optionals — combine these lambda skills with Optional to eliminate null pointer exceptions for good.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary