Skip to main content

6. Lambdas and Funtional Interfaces

1. Lambda Expressions​

A lambda is an anonymous function that we can handle as a first-class language citizen. For instance, we can pass it to or return it from a method.

2. Functional Interfaces​

Any interface with a single abstract method is a functional interface, and its implementation may be treated as lambda expressions.

💡 It’s recommended that all functional interfaces have an informative @FunctionalInterface annotation. This clearly communicates the purpose of the interface, and also allows a compiler to generate an error if the annotated interface does not satisfy the conditions.

⚠️ An interface with only one method is functional but can still have default methods.

3. Functions​

The most simple and general case of a lambda is a functional interface with a method that receives one value and returns another. This function of a single argument is represented by the Function interface, which is parameterized by the types of its argument and a return value.

/**
* Represents a function that accepts one argument and produces a result.
*
* This is a functional interface whose functional method is apply(Object).
*
* @param <T> the type of the input to the function
* @param <R> the type of the result of the function
*/
@FunctionalInterface
public interface Function<T, R> {

/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
}

Primitive Function Specializations​

⚠️ Since a primitive type can’t be a generic type argument, there are versions of the Function interface for the most used primitive types double, int, long, and their combinations in argument and return types:

  • IntFunction, LongFunction, DoubleFunction : arguments are of specified type, return type is parameterized
  • ToIntFunction, ToLongFunction, ToDoubleFunction : return type is of specified type, arguments are parameterized
  • DoubleToIntFunction, DoubleToLongFunction, IntToDoubleFunction, IntToLongFunction, LongToIntFunction, LongToDoubleFunction: having both argument and return type defined as primitive types, as specified by their names

Two-Arity Function Specializations​

💡 To define lambdas with two arguments, we have to use additional interfaces that contain “Bi” keyword in their names: BiFunction, ToDoubleBiFunction, ToIntBiFunction, and ToLongBiFunction.

4. Suppliers​

The Supplier functional interface is yet another Function specialization that does not take any arguments. We typically use it for lazy generation of values. There is no requirement that a new or distinct result be returned each time the supplier is invoked.

/**
* Represents a supplier of results.
*
* This is a functional interface whose functional method is get().
*
* @param <T> the type of results supplied by this supplier
*/
@FunctionalInterface
public interface Supplier<T> {

/**
* Gets a result.
*
* @return a result
*/
T get();
}

Example :

static Supplier<TodoNotFoundException> getTodoNotFoundExceptionSupplier(UUID id) {
return () -> new TodoNotFoundException(id);
}

💡 Optional.orElseThrow method implements the Supplier functional interface.

5. Consumers​

The Consumer accepts a generified argument and returns nothing. It is a function that is representing side effects.

/**
* Represents an operation that accepts a single input argument and returns no
* result. Unlike most other functional interfaces, Consumer is expected
* to operate via side-effects.
*
* <p>This is a functional interface whose functional method is {accept(Object).
*
* @param <T> the type of the input to the operation
*/
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
}

Example :

Consumer<Todo> getTodoConsumer() {
return (todo) -> todoRepository.remove(todo);
}

💡 List.forEach method implements the Consumer functional interface.

6. Predicates​

In mathematical logic, a predicate is a function that receives a value and returns a boolean value. A typical use case of the Predicate lambda is to filter a collection of values.

The Predicate functional interface is a specialization of a Function that receives a generified value and returns a boolean.

/**
* Represents a predicate (boolean-valued function) of one argument.
*
* This is a functional interface whose functional method is test(Object).
*
* @param <T> the type of the input to the predicate
*/
@FunctionalInterface
public interface Predicate<T> {

/**
* Evaluates this predicate on the given argument.
*
* @param t the input argument
* @return true if the input argument matches the predicate, otherwise false.
*/
boolean test(T t);
}

Example :

Predicate<Todo> getTodoPredicate(Todo todoToUpdate) {
return todo -> !todo.equals(todoToUpdate);
}

💡 filter or anyMatch methods implements the Predicate functional interface.

7. Operators​

Operator interfaces are special cases of a function that receive and return the same value type.

/**
* Represents an operation on a single operand that produces a result of the
* same type as its operand. This is a specialization of Function for
* the case where the operand and result are of the same type.
*
* This is a functional interface whose functional method is apply(Object).
*
* @param <T> the type of the operand and result of the operator
*/
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

/**
* Returns a unary operator that always returns its input argument.
*
* @param <T> the type of the input and output of the operator
* @return a unary operator that always returns its input argument
*/
static <T> UnaryOperator<T> identity() {
return t -> t;
}
}

Example:

static UnaryOperator<String> getStringUnaryOperator() {
return name -> name.toUpperCase();
}

💡 List.replaceAll method implements the UnaryOperator functional interface.

References​