Java 8: Lambdas, Functional Interfaces and Default Methods

Description

Java 8 (2014) changed how Java is written more than any release before or since. Its big idea was letting you pass behavior around as easily as data: "sort these orders by total", "keep only the large ones", "run this when the payment completes". Before Java 8, each of those needed a bulky anonymous class. After it, a one-line lambda does the job, and streams, Optional, CompletableFuture and most modern libraries are built around that idea.

Interviewers still ask "what came in Java 8?", and much production code still targets it. This skill covers the language half: lambdas, the interfaces they implement, method references, and default methods in interfaces. The next two skills cover streams, then Optional and java.time.

Here's the path, from easiest to most technical:

1. From anonymous class to lambda.
2. Functional interfaces: the "shapes" a lambda can fit.
3. Method references: an even shorter lambda.
4. What a lambda can use from around it, and why checked exceptions get in the way.
5. Combining functions, and default methods in interfaces.

From anonymous class to lambda

Here's "sort orders by total" before and after Java 8:

// Before: an anonymous class
orders.sort(new Comparator<Order>() {
    @Override
    public int compare(Order a, Order b) {
        return Long.compare(a.total(), b.total());
    }
});

// After: a lambda
orders.sort((a, b) -> Long.compare(a.total(), b.total()));

A lambda is written as (parameters) -> body. The body is either one expression (its value is returned) or a block in braces (with an explicit return if it returns something). Java works out the parameter types from where the lambda is used, so you rarely write them.

Functional interfaces: the shapes a lambda fits

A lambda can be used anywhere Java expects a functional interface: an interface with exactly one abstract method. The lambda becomes the implementation of that method. Java 8 added a standard set in java.util.function, and you'll see these everywhere:

A few details:

• Primitive versions such as IntPredicate, ToIntFunction and IntUnaryOperator work with plain ints. A Predicate<Integer> boxes every number it tests, which matters in hot loops.
• @FunctionalInterface on your own interface makes the compiler check that it has exactly one abstract method.
• Default methods, and methods like equals that come from Object, don't count toward the "one abstract method".

Method references

When a lambda just calls one existing method, a method reference says the same thing more briefly:

The "almost": logger::flush looks up logger once, when the reference is created, and keeps calling that object. The lambda () -> logger.flush() reads the logger field each time it runs. If the field is later replaced, the two behave differently. And if logger is null, the method reference throws a NullPointerException immediately, while the lambda would throw only when called.

What a lambda can use from around it

A lambda can read the variables around it, with one rule that trips everyone up at first:

int skipped = 0;
orders.forEach(o -> {
    if (o.isTest()) skipped++;    // doesn't compile: local variables referenced from a lambda
});                               // expression must be final or effectively final

A lambda copies the values of the local variables it uses, so Java requires those variables never to change after they're set (they must be effectively final, whether or not you write final). The fix is usually to stop mutating and compute the answer instead:

long skipped = orders.stream().filter(Order::isTest).count();

Two more rules:

• Fields aren't copied. A lambda reads instance fields when it runs, so it sees their current values.
• this means the surrounding object. Inside a lambda, this is the object whose method created the lambda. Inside an anonymous class, this is the anonymous object itself.

Checked exceptions are the other common wall. Consumer.accept and Function.apply don't declare any, so this doesn't compile:

paths.forEach(p -> process(Files.readString(p)));   // unreported exception IOException

Either catch inside the lambda and rethrow as an unchecked exception (UncheckedIOException for I/O), or write a small functional interface of your own whose method declares throws IOException, or keep a plain for loop.

Combining functions

Functional interfaces come with methods for combining them:

Function<Integer, Integer> plusOne = x -> x + 1;
Function<Integer, Integer> timesTwo = x -> x * 2;

plusOne.andThen(timesTwo).apply(5);   // 12: plusOne first, then timesTwo
plusOne.compose(timesTwo).apply(5);   // 11: timesTwo first, then plusOne

Predicate<Order> large = o -> o.total() > 10_000;
Predicate<Order> test = Order::isTest;
Predicate<Order> realLargeOrder = large.and(test.negate());

andThen reads in the order things happen; compose runs its argument first. Mixing them up is a classic bug.

Default methods in interfaces

Before Java 8, adding a method to an interface broke every class that implemented it. Default methods (interface methods with a body) fixed that, and that's how forEach, stream() and getOrDefault were added to Java's existing collection interfaces.

When a class could inherit the same method from more than one place, three rules decide which one runs:

1. The class wins. A method from a superclass beats an interface's default.
2. The more specific interface wins. If B extends A and both have the default, B's is used.
3. Otherwise it doesn't compile, and the class must override the method itself (it can call one of them with A.super.greet()).

Interfaces can also have static methods, such as Comparator.naturalOrder(). They belong to the interface only and aren't inherited, so you always call them through the interface name.

Common mistakes

Check yourself

Try to answer before opening each one. Recalling beats re-reading.

1. Why can a lambda read a local variable but not increment it?

2. What's the difference between logger::flush and () -> logger.flush() when logger is a field that later gets replaced?

3. What do plusOne.andThen(timesTwo).apply(5) and plusOne.compose(timesTwo).apply(5) return?

4. A class extends Base (which has greet()) and implements Greeter (which has a default greet()). Which one runs?

Key takeaways

• A lambda is a short implementation of a functional interface: one abstract method, such as Predicate, Function, Consumer or Supplier.
• Method references shorten lambdas that call one method; a reference to an object fixes that object when it's created.
• Lambdas capture effectively final locals, read fields live, and use the enclosing this. Checked exceptions need wrapping.
• andThen runs this then that; compose runs that then this.
• Default methods let interfaces grow: the class wins, the more specific interface wins, and clashes must be overridden.