Lambda Expressions in Java: Syntax and Examples. Practical Tasks

The most common way exercise 2 below breaks is a swapped pair of predicates. The call notEmpty.and(notNull).test(null) throws NullPointerException even though the null check is right there in the code. The reason: and() evaluates left to right and short-circuits, so !s.isEmpty() runs first and blows up on null. The working order is notNull.and(notEmpty). Details like this stay invisible while you read theory and surface the moment you write the code yourself.

A lambda expression in Java is a compact way to implement a functional interface - an interface with exactly one abstract method - without writing an anonymous class. Lambdas and method references arrived in Java 8 and are still the foundation of the Stream API and of functional-style code in the language. Below are 7 practice problems, from a bare () -> ... up to predicate composition and a static method reference. Most of them come with a video walkthrough of the solution.

What to review before you start

Every exercise leans on one built-in functional interface from the java.util.function package. If you forgot a signature, open the matching lesson in a second tab - but write the solution yourself.

For the theory itself, see the lesson on lambda expressions in Java.

Exercise 1. A lambda for the Printable interface

Declare your own interface Printable with a single method void print() and implement it with a lambda expression that prints any message to the console.

@FunctionalInterface
interface Printable {
    void print();
}
// Printable printable = ...;
// printable.print();

Note that the method takes no parameters, so the parameter list of the lambda is a pair of empty parentheses. The @FunctionalInterface annotation is optional, but it makes the compiler verify that there really is exactly one abstract method.

Exercise 2. Null and empty string check (Predicate.and)

This one has three steps and is built on the Predicate interface:

1. Write a Predicate<String> lambda that returns true when the string is not null.
2. Write a second Predicate<String> lambda that returns true when the string is not empty.
3. Combine both with the default method and() into a single "not null and not empty" check and test it against null, "" and "Java".

Predicate<String> notNull = s -> /* your code */;
Predicate<String> notEmpty = s -> /* your code */;

Predicate<String> hasText = /* combine them here */;

System.out.println(hasText.test(null));    // false
System.out.println(hasText.test(""));      // false
System.out.println(hasText.test("Java"));  // true

Video solution →

Exercise 3. First and last letter of a string (Predicate.or)

Write a program that checks whether a string starts with the capital letter 'J' or 'N' and at the same time ends with the capital letter 'A'. Build the check out of separate Predicate<String> instances combined with or() and and().

Test it on "Java", "Nika", "Scala" and "java". The check is case-sensitive, so "java" must return false.

Video solution →

Exercise 4. Consumer and andThen

You have a class HeavyBox with a weight field. Write a lambda of type Consumer<HeavyBox> that takes a HeavyBox and prints "Shipped a box weighing n", where n is the weight of that box.

Then create a second Consumer<HeavyBox> - printing the delivery address, for example - and chain both actions together with the default method andThen(). Make sure both messages are printed for the same object and in the expected order.

Video solution →

Exercise 5. Sign of a number with Function

Write a lambda of type Function<Integer, String> that takes a number and returns the string "Positive number", "Negative number" or "Zero".

Function<Integer, String> sign = n -> /* your code */;

System.out.println(sign.apply(7));   // Positive number
System.out.println(sign.apply(-3));  // Negative number
System.out.println(sign.apply(0));   // Zero

Video solution →

Exercise 6. Random number with Supplier

Write a lambda of type Supplier<Integer> that returns a random integer from 0 to 10 inclusive. Call get() several times in a loop and confirm that the values change while both ends of the range stay reachable and are never exceeded.

Video solution →

Exercise 7. Static method reference

Go back to exercise 1 and rewrite the Printable implementation as a static method reference: move the body of the lambda into a separate static method and pass it as ClassName::methodName.

Self-check before you watch the solutions

Run through this short list first - it catches most of the mistakes beginners make with lambdas:

1. Does the code compile without warnings and without an explicit cast? If you need a cast, you probably picked the wrong functional interface.
2. Did you test the boundary values: null, an empty string, zero, a negative number?
3. Are you trying to modify a local variable of the enclosing method inside the lambda? That will not compile - captured variables must be effectively final.
4. Are there braces and a return where a single expression would have been enough?
5. Does the formatting follow the code style checklist?