Module 3: Java Lambda Expressions

Key Topics

• Functional interfaces and their role in lambda expressions
• Lambda syntax and parameter types
• Method references as lambda alternatives
• Using built-in functional interfaces from java.util.function
• Stream operations with lambda expressions
• Implementing custom functional interfaces

Functional Interfaces with Lambda Expressions

Lambda expressions and interfaces

In a prior lesson, you learned about interfaces in Java such as List<E> for example. Interfaces are "contracts" that define how a class should behave. An interface's method signatures define the behaviors. The methods do not have implementations in the interface, so we call them "abstract". For example, in the List interface, get() and add() are abstract methods. Classes implement interfaces. The implementing classes must implement the interface's abstract methods, matching the method signatures. ArrayList<E> implements List<E>, and overrides the get() and add() methods (as well as the other List methods). This reading covers a group of built-in Java interfaces, called functional interfaces. We also cover a concise way to implement those interfaces with lambda expressions.

What are functional interfaces and lambda expressions?

We call any interface with exactly one abstract method a "functional interface". The List interface defines multiple methods, so it is not a functional interface. Developers can create new functional interfaces, but the Java library provides some useful functional interfaces as well. We call these the standard Java functional interfaces. We will cover four standard Java functional interfaces, focusing on the Function interface and Supplier interface. We will then learn how to use lambda expressions to implement these functional interfaces without defining a class.

Before we talk about the specifics of each functional interface, let's go over lambda expressions at a high level. Typically, implementing an interface requires writing a full class definition. The class header declares which interface it's implementing, and the class implementation overrides each abstract method. Creating and documenting an entire class could feel like a great deal of effort just to implement the single method in a functional interface. That's where lambda expressions come in handy.

As we mentioned, lambda expressions provide a quick way to implement a functional interface without explicitly defining a class or even a formal method declaration. Because each functional interface contains exactly one abstract method, lambda expressions allow us to implement only that one method to satisfy the interface. We don't need to create a class, and since the interface has only one method, we don't even need to name it!

Here's a short example of a lambda expression: value -> value == null;. The compiler converts that one line into a class that implements a functional interface. Its single method accepts one parameter (value) and returns a boolean. Imagine writing a whole class definition just for one line of code!

Since lambda expressions represent a class that implements an interface, you can assign them to a variable that references that interface. (Polymorphism!) They can also be written inline when needed. This means a lambda expression can be written anywhere you can declare or use a variable and can even be written inside another method call.

The Predicate functional interface takes one parameter and returns a boolean. The List method removeIf(Predicate filter) uses Predicate. It invokes the provided Predicate for every value stored in the List and removes it if the Predicate returns true.

If we assume a List called numberList exists and is populated with Integers, we could use our example lambda expression to remove each null value:

numberList.removeIf(value -> value == null);

It is less common, but we could also store the Predicate in a local variable, then pass it in to removeIf():

Predicate<Integer> isNull = value -> value == null;
numberList.removeIf(isNull);

If we were to write an explicit class to implement this interface, we'd need a separate class. To call it in removeIf(), we'd need to instantiate it. The examples above are equivalent to:

// CheckIfNull.java

/**
* An Integer filter/predicate that returns true when the
* provided Integer is null.
*/
public class CheckIfNull implements Predicate<Integer> {
    @Override
    public boolean test(Integer integer) {
        return null == integer;
    }
}
...

Predicate<Integer> checkIfNull = new CheckIfNull();
numberList.removeIf(checkIfNull);

That's a lot more complicated than the single-line lambda expression! Lambda expressions are often much quicker and easier to read than an entire class implementation.

The lambda expression declares a class and a method implementation; it does not invoke the method. In our example above, value is not a defined variable when we write value -> value == null, so Java can't invoke our lambda anyway. Even if a value variable existed, Java would not invoke our lambda; instead, the compiler builds the class the lambda expression defines.

An anonymous method is a method without a formal method declaration. You can define it in-line with a method body only. Lambda expressions are one example of an anonymous method. You have also created an anonymous method in your test code when calling JUnit's assertThrows() method, for example.

Anonymous methods have scope similar to Java variables. Like variables, if a lambda expression is defined at the top of a class and assigned to a variable it has class scope: any method in that class can access the lambda expression.

A lambda expression defined inside a block of code such as an if statement or for loop has block scope. A lambda expression with block scope cannot be accessed outside of the block of code in which it was declared. Curly braces define a block of code. A lambda expression written in-line such as the example above, numberList.removeIf(value -> value == null); is only available to the method it's passed to (in this case, removeIf()). Note that this is by far the most common usage.

Lambda expression usage

Now that we've discussed the use case for lambda expressions, let's talk about how to create and use one. We'll start with one example of a standard Java functional interface: Function<T,R>, then move on the others.

The Function interface

The first functional interface we want to introduce is Function<T,R>. This functional interface defines a method that accepts one parameter of type T, and returns a return value of type R. The two types can be any Java class or interface types, and can even be the same type.

The interface definition itself is:

public interface Function<T,R> {
    R apply(T t);
}

Notice that this follows the same rules as other Java interfaces that we've seen. The declaration uses the keyword, interface. There is exactly one method signature and it is followed by a semicolon, with no implementation.

Before we show how a lambda expression makes implementing this interface easy, let's look at what a normal implementation would look like. We are going to use an example that assesses the value of an item, returning a String representation of the quality. If the input price is below a certain amount, we return "That's a great price!". If the input price is above a certain amount, we return "That's too expensive!" If the input price is somewhere in the middle, we will return, "That's a fair price.". Let's look at what a full class definition would look like (reminder: we'll declare the class for instructional purposes here, but we'll see how it is actually done in practice shortly):

public class PriceEvaluator implements Function<BigDecimal, String> {
    public String apply(BigDecimal price) {
        if (price.compareTo(new BigDecimal(50)) < 0) {
            return "That's a great price!";
        } else if (price.compareTo(new BigDecimal(100)) < 0) {
            return "That's a fair price.";
        } else {
            return "That's too expensive!";
        }
    }
}

To implement the Function interface, the class header must declare that it will implement the interface. Since Function is a generic interface, we must also declare the types being used. We are creating a class named PriceEvaluator that implements the interface Function with BigDecimal as the input type (T) and String as the result type (R):

public class PriceEvaluator implements Function<BigDecimal, String>

Next, we must override Function's abstract method, apply(). This method takes in a BigDecimal, which we've named price, and returns a String:

public String apply(BigDecimal price) {

We can declare and instantiate PriceEvaluator like any other class:

PriceEvaluator priceEvaluator = new PriceEvaluator();
String response = priceEvaluator.apply(new BigDecimal(5));

After running this code snippet, the response would be "That's a great price!".

As we learned with, polymorphism allows us to assign the new instance to a variable that is of the Function interface type, rather than the concrete type. This still allows us to call the apply() method, as it is defined in the interface:

Function<BigDecimal, String> priceEvaluator = new PriceEvaluator();
String response = priceEvaluator.apply(new BigDecimal(5));

After running this code snippet, the response would still be "That's a great price!".

Let's now use a lambda expression instead of a separate class definition. First, we'll we assign the lambda expression to a variable, also of type Function<BigDecimal, String>:

Function<BigDecimal, String> priceEvaluator = price -> {
    if (price.compareTo(new BigDecimal(50)) == -1) {
        return "That's a great price!";
    } else if (price.compareTo(new BigDecimal(100)) == -1) {
        return "That's a fair price.";
    } else {
        return "That's too expensive!";
    }
};

Since the class created by our lambda expression has no name, we can only declare the variable of the interface type on the left-hand side of the equal sign:

Function<BigDecimal, String> priceEvaluator

This is similar to the example above where we used a class to implement the interface and we could assign it to a variable of the Function type, Function<BigDecimal, String> priceEvaluator = new PriceEvaluator();. The change defines the lambda expression for the implementing method inline rather than in a separate class file. On the right-hand side, we define the lambda expression instead of instantiating a new PriceEvaluator(). This provides the implementation for the Function interface's apply() method that we must override. Because the functional interface has just one method, Java knows exactly which method is being overridden, even though we don't say that we're implementing apply().

There are three parts to the lambda expression:

• The method argument(s)
• The arrow separator: ->
• The method implementation (inside the curly braces)

Immediately following the equals sign above, we see parts 1 and 2:

... = price -> {

The variable price is the single argument to the apply() method. This variable is a BigDecimal. Java knows this by the first generic type declared in Function<BigDecimal, String>. The method argument can also be enclosed in parentheses like this:

... = (price) -> {

When there is only one input argument in the lambda expression, using parentheses is optional. Note that ATA's checkstyle will prevent you from using parentheses if there is only one argument. When there are multiple inputs or no input you must use parentheses.

After the input argument comes an arrow sign formed with a hyphen (-) and a greater-than sign (>). This separates the inputs from the method implementation. Following the arrow sign is an open curly brace that begins the method implementation. The curly braces are optional if you have only one line of code in your method. Since our example has multiple lines of code, we need the curly braces. The rest of the code sample is:

if (price.compareTo(new BigDecimal(50)) < 0) {
    return "That's a great price!";
} else if (price.compareTo(new BigDecimal(100)) < 0) {
    return "That's a fair price.";
} else {
    return "That's too expensive!";
}

In this example, we have multiple return statements, which is fine for a functional interface that has a return value, just as with any method that returns a value. Some functional interfaces define methods with void return type, so they don't require return statements. Others do have return values, but the return statement is implied. We'll see examples of both later in this lesson.

Once the lambda expression is implemented, we could use it like this:

Map<BigDecimal, String> priceMap = fetchPriceMapping();
BigDecimal itemPrice = new BigDecimal("49.99");
priceMap.computeIfAbsent(itemPrice, priceEvaluator);

priceMap maps prices of items to the String "evaluation" of the price. The method, computeIfAbsent(), accepts a BigDecimal key and a Function. computeIfAbsent() first checks if the map contains the key. If the key already exists, computeIfAbsent() immediately returns. If the key does not exist in the map, computeIfAbsent() will add the key, mapping it to the value returned by calling the lambda expression, passing in itemPrice as its argument. After this code runs, priceMap would contain the entry:

<49.99, "That's a great price!">

Now, let's see how Java developers actually write this code: writing lambda expressions inline. Here, we'll pass the lambda expression directly into the computeIfAbsent() method as its second argument, rather than storing it in a local variable first. Because we're not using a variable, we don't have to declare the interface type. Here's what it looks like:

map.computeIfAbsent(itemPrice, price -> {
    if (price.compareTo(new BigDecimal(50)) < 0) {
        return "That's a great price!";
    } else if (price.compareTo(new BigDecimal(100)) < 0) {
        return "That's a fair price.";
    } else {
        return "That's too expensive!";
    }
});

Using a lambda expression can save time and increase readability compared to the first example where we wrote a whole class to implement this interface. Now that we have walked through an example of lambda expressions using the Function interface, let's move on to another standard Java functional interface, the Supplier interface.

Supplier interface

Our next functional interface is Supplier<T>, where T is the type of the result returned. A Supplier provides an object (often by generating a new one or pulling from a data structure) each time it is called. The code for the interface is:

public interface Supplier<T> {
    T get();
}

The abstract method in the Supplier functional interface is the get() method. Since get() has no method parameters, we only have one generic type, the result. It does not take input directly, but may access any variables within its scope to compute the next value to return.

Let's look at an example that generates a random index of a list. We mentioned Suppliers may use variables in its scope to help determine what value to return. In this example we see a Random and a List being used. (For instructional purposes, we'll assign a variable to the lambda.)

List<String> participants = ImmutableList.of("Ana", "Mary", "Carlos");
Random random = new Random();
Supplier<Integer> randIndexGenr = () -> random.nextInt(participants.size());

We declare a variable of the interface type, Supplier<Integer>. We've named the variable randIndexGenr (short for random index generator, to fit on one line in this reading). On the right side of the equal sign, we begin with empty parentheses: the Supplier functional interface takes no input into its get() method, so the parentheses are required and must be empty. Next, comes the arrow separator and then get()'s implementation. After the arrow, we do not have curly brackets because the body of the method is only one line and thus brackets aren't required. It doesn't appear to have a return statement, but it actually does!:

random.nextInt(participants.size());

If you drop the curly braces from your method, and the functional interface that your lambda expression is implementing has a return value, you drop the keyword return. It is most common to drop the curly braces and the return keyword, so you will often see it written that way! We could write it without this simplification for comparison (but don't do it this way!):

Supplier<Integer> randomIndexGenerator = () -> {
    return random.nextInt(participants.size());
};

Now, let's look at a method that accepts a Supplier as an argument:

public void callOnParticipant(Supplier<Integer> indexChooser) {
    String participant = participants.get(indexChooser.get());
    System.out.println(participant + ", can you please share your answer?");
    System.out.println("Thank you.");
}

As we've seen above, we can pass a lambda expression that we have stored in a variable to the method (not usually done this way):

callOnParticipant(randomIndexGenerator);

Or we can write the lambda inline (usually done this way!):

callOnParticipant(() -> random.nextInt(participants.size()));

Note: The one case where you use a variable to store the lambda expression is if you pass the identical lambda expression into multiple methods. In this case, you should not rewrite the lambda expression inline each time you want to use it. Pass your variable. The inline example is showing how to create and use a lambda expression for a single use. Because the single-use is the most common, you'll most often create and pass your lambda expressions inline.

Understanding Functional Interfaces

A functional interface in Java is an interface that contains exactly one abstract method. Lambda expressions provide a way to implement these interfaces concisely.

Here's an example of a functional interface and its implementation using lambda expression:

// Functional interface definition
@FunctionalInterface
interface StringProcessor {
String process(String input);
}

// Implementation using a lambda expression
StringProcessor reverser = (String s) -> {
StringBuilder sb = new StringBuilder(s);
return sb.reverse().toString();
};

// Usage
String result = reverser.process("Hello");  // Returns "olleH"

The key built-in functional interfaces in the java.util.function package include:

• Function<T,R>: Takes a T argument and returns an R result. Method: R apply(T t)
• Consumer<T>: Takes a T argument and returns no result. Method: void accept(T t)
• Supplier<T>: Takes no arguments and returns a T result. Method: T get()
• Predicate<T>: Takes a T argument and returns a boolean. Method: boolean test(T t)

Summary

In this reading we learned about Java's functional interfaces. We showed how a lambda expression can simplify implementing a functional interface using two different specific functional interfaces as examples. In the next reading, we will cover two more common functional interfaces (note: there are many more Java functional interfaces, but you do not need to know/memorize these; just know that they exist for now). For now, let's stop here so you can give these two functional interfaces a try.

Advanced Lambda Expressions

Method References

Method references provide an even more concise way to express lambda expressions that simply call an existing method.

There are four types of method references:

// 1. Reference to a static method
Function<String, Integer> parser = Integer::parseInt;

// 2. Reference to an instance method of a particular object
String str = "Hello";
Supplier<Integer> lengthSupplier = str::length;

// 3. Reference to an instance method of an arbitrary object of a particular type
Function<String, Integer> lengthFunc = String::length;

// 4. Reference to a constructor
Supplier<List<String>> listSupplier = ArrayList::new;

Lambda Expressions with Streams

Java's Stream API works seamlessly with lambda expressions to process collections of objects:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave");

// Filter names starting with 'A'
List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("A"))
    .collect(Collectors.toList());

// Transform names to uppercase
List<String> upperNames = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// Find any name longer than 5 characters
Optional<String> longName = names.stream()
    .filter(name -> name.length() > 5)
    .findAny();

// Combine multiple operations
double averageLength = names.stream()
    .filter(name -> name.length() > 3)
    .mapToInt(String::length)
    .average()
    .orElse(0);

Resources