Lambda expressions in Java

This post is about using lambda expressions in Java. Lambda expressions are functions without a name that are commonly used in the functional programming style, specially to do iterations and filtering of lists.

The way to define a lambda expression type is to define an interface with a single abstract (not defined) method:

public interface Predicate<T> {
    public boolean check(T object);
}

Then another method could call a lambda expression defining the previous type, such as code like this:

public static filter(List<T> list, Predicate<T> fun) {
    List<T> result = new ArrayList<T>();
    for(T x : list) {
        if(fun.check(x)) result.add(x);
    }
    return result;
}

What’s now left is to define the code that will check our properties in the filter function and return the list containing those objects that match the predicate:

List<String> data = List.of("hello", "world", "hi");
List<String> result = 
    filter(data, (s) -> s[0] == 'h'));

In this code sample, a lambda expression is used to return a boolean value corresponding to true if the string starts with the letter “h”. The value returned is a list with the elements that match the condition passed as a lambda expression.

Lambda functions can be expressions (Java code that evaluates to a value) or if wrapped by curly braces ({}) a sequence of statements or instructions that optionally return a value.

Common functional interfaces

Predicates

One commonly used functional interface is Predicate<T> which specifies in its interface a function boolean test(T t). We could have defined in our previous example the argument to the function filter as a Predicate instead of creating our own interface.

The function filter from the class java.util.stream.Stream takes one Predicate function as an argument, filtering out of the stream the elements that do not match the condition specified in it.

Other functions in Stream that accept Predicate arguments are:

• allMatch, which takes a Predicate object and returns as a boolean whether all elements of a stream match the given predicate.
• anyMatch, which is similar to allMatch but returns true if at least one element of the stream matches the predicate.
• noneMatch, which returns true if no elements of the stream match the given predicate.

Functions

The functional interface Function<T,R> specifies the interface for a lambda function that takes one argument of type T and returns a value of type R.

The usual Stream operator that accepts an object of type Function is the map operator, which applies the function to every element of the stream and gives as an output in the destination stream the return value of the Function.

Consumers

The Consumer<T> functional interface defines a function that accepts one argument of type T and returns nothing, or void. This is used to process the stream with a function that normally has a side-effect, such as sending data to a database or a file, and wants not to pass any result to the stream, but instead “consumes” it or takes it out of the stream.

A Stream function that would use a Consumer interface is the method forEach, which just calls the function for each element, consuming all elements of the stream. Another Stream function taking a Consumer argument would be peek, which returns the stream intact to allow other operations, but executes the input function every time that an element of the stream is consumed.

Manipulating collections with lambda functions and streams

The main class that implements functional methods such as map, filter, et c. is the class Stream. One can use Stream directly or instead convert one of the many types that extend or implement java.util.Collection, such as LinkedList, to a Stream object.

To do that, one would call the function stream() of any list or object that subclassed the class java.util.Collection. If needed, the final result of the operations could be converted back to a List object by calling Stream‘s function toList().

References

• Lambda Expressions, Java Reference.
• java.util.function package, Java 21 Reference.
• java.util.Collection, Java 21 Reference.
• java.util.List class, Java 21 Reference.
• java.util.stream.Stream class, Java 21 Reference.