1. Introduction

Java, known for its object-oriented paradigm, took a significant leap towards functional programming with the introduction of lambdas in Java 8. Lambdas allow developers to write code more concisely and expressively, focusing on what needs to be done rather than dealing with the state of objects. You focus more on expressions than loops. Lambda expressions provide a concise way to represent anonymous methods or functions. At its core, a lambda expression is a block of code that can be passed around as if it were a variable. It encapsulates a set of actions and represents an anonymous function — a method without a name.

Let’s explore this with a code example. Our goal is to print out all the species from a list that can bark. First we show you how to do this without lambdas to illustrate how lambdas are usefull:

without lambdas

public class Species {
    private String name;
    private boolean canTalk;
    private boolean canBark;

    public Species(String name, boolean talks, boolean barks) {
        this.name = name;
        this.canTalk = talks;
        this.canBark = barks;
    }

    public boolean canTalk() {
        return canTalk;
    }

    public boolean canBark() {
        return canBark;
    }

    public String getName() {
        return name;
    }
}

public interface CheckSound {
    boolean test(Species species);
}

public class CheckIfBarks implements CheckSound {
    @Override
    public boolean test(Species species) {
        return species.canBark();
    }
}

import java.util.ArrayList;
import java.util.List;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {

        List<Species> speciesList = new ArrayList<>();
        speciesList.add(new Species("Bob", true, false));
        speciesList.add(new Species("Garfield", false, false));
        speciesList.add(new Species("Max", false, true));
        speciesList.add(new Species("Steven", true, false));
        speciesList.add(new Species("Scooby Doo", true, true));

        System.out.println("the species that can bark are: ");
        print(speciesList, new CheckIfBarks());
        System.out.println("the species that can talk are: ");
        print(speciesList, species -> species.canTalk());
    }

    private static void print(List<Species> speciesList, CheckSound soundChecker) {
        for (Species species : speciesList) {
            if (soundChecker.test(species)) {
                System.out.println(species.getName());
            }
        }
    }
}

Let’s break down the code and understand what it does:

1. Species Class:
   • Represents a species with attributes such as name, whether it can talk (canTalk), and whether it can bark (canBark).
   • It has a constructor to initialize these attributes and getter methods to access them.
2. CheckSound Interface:
   • Defines a functional interface with a single method test(Species species).
   • This interface is intended to be implemented by classes that check certain sound-related properties of species.
3. CheckIfBarks Class:
   • Implements the CheckSound interface.
   • Overrides the test method to check if a given species can bark.
   • It returns true if the species can bark, otherwise false.
4. Main Class:
   • Contains the main method, which is the entry point of the program.
   • Inside main, it creates a list of Species objects with different characteristics.
   • It then calls the print method, passing the list of species and an instance of CheckIfBarks as parameters.
5. print Method:
   • Takes a list of Species and an object implementing the CheckSound interface as parameters.
   • Iterates over each Species in the list.
   • For each species, it calls the test method of the CheckSound object passed as a parameter, passing the species.
   • If the test method returns true (indicating the species can bark), it prints its name.

In the main method, speciesList is populated with different species, each having different properties related to talking and barking. Then, the print method is invoked with CheckIfBarks as the soundChecker parameter. This means it will print out the names of the species that can bark, based on the implementation of the CheckIfBarks class.

with lambdas

Let’s see what would happen if we wanted to print all the species that can talk. Without the use use of lambdas we would need to write another class, ChekcIfTalks, and instantiate that class in the main method to use it there. Why can’t we just specify the logic we care about right here? Well, with lambda expressions we can. We just need to add teh following line to the main method:

        print(speciesList, species -> species.canTalk());

so now the main method looks like this:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {

        List<Species> speciesList = new ArrayList<>();
        speciesList.add(new Species("Bob", true, false));
        speciesList.add(new Species("Garfield", false, false));
        speciesList.add(new Species("Max", false, true));
        speciesList.add(new Species("Steven", true, false));
        speciesList.add(new Species("Scooby Doo", true, true));

        System.out.println("the species that can bark are: ");
        print(speciesList, new CheckIfBarks());
        System.out.println("the species that can talk are: ");
        print(speciesList, species -> species.canTalk());
    }

    private static void print(List<Species> speciesList, CheckSound soundChecker) {
        for (Species species : speciesList) {
            if (soundChecker.test(species)) {
                System.out.println(species.getName());
            }
        }
    }
}

output:

the species that can bark are: 
Max
Scooby Doo
the species that can talk are: 
Bob
Steven
Scooby Doo

2. Syntax

The syntax of lambda expressions relies on context to infer the types of parameters and return values. Lambdas work with interfaces that have only one abstract method. In the example of the CheckSound interface that method was:

    boolean test(Species species);

The lambda we wrote in our main method, indicated that Java should call a method with a Species parameter that returns a boolean value that is the result of canTalk. When we are passing a lambda as the second paramter of the print() method, Java knows that the method expects a CheckSound as the second parameter. Since the interface method takes a species, that means the lambda paramter has to be a Species. Since the interface method returns a boolean, we know the lambda returns a boolean.

A lambda expression consists of the following parts:

1. Parameter List:
   • Parentheses are optional when there’s only one parameter. They become mandatory for zero or multiple parameters.
   • Parameter types can be omitted if they can be inferred, but they can also be explicitly declared.
2. Arrow Token:
   • The arrow token -> separates the parameter list from the body of the lambda expression.
3. Body:
   • If the body of the lambda expression consists of a single expression, curly braces can be omitted. Java will automatically return the result of that expression.
   • If the body requires multiple statements, curly braces are mandatory, and a semicolon is needed after each statement. Also, a return statement must explicitly specify the return value.

examples:

// Parentheses are required for zero parameters
() -> true

// Parentheses are optional for single parameter
a -> a.startsWith("test");

// Parentheses are required for multiple parameters
(a, b) -> a.length() == b;

// Explicitly declare parameter types
(String a, String prefix) -> a.startsWith(prefix);

// Curly braces are mandatory for multiple statements
s -> {
    System.out.println(s);
    System.out.println(s.startsWith("test"));
};

// Curly braces, semicolon, and return statement are required
a -> {
    boolean result = a.endsWith("end");
    return result;
};

3. Functional Interfaces

Functional interfaces are interfaces that contain exactly one abstract method, known as the Single Abstract Method (SAM) rule. In Java, functional interfaces enable the use of lambda expressions to represent instances of single-method interfaces, promoting a functional programming style within the language. Here are four common functional interfaces and their usage:

3.1. Predicate

• Purpose: Represents a condition or test that can be applied to an object of a certain type, resulting in a boolean value.
• Usage: Typically used for filtering elements in a collection or checking if an object meets certain criteria.

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

example:

Predicate<Integer> isPositive = n -> n > 0;
System.out.println(isPositive.test(5)); // Output: true

3.2. Consumer

• Purpose: Represents an action or operation that consumes an input but does not return any result.
• Usage: Commonly used for performing side effects, such as printing to the console, updating state, or invoking methods with side effects.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

example:

Consumer<String> printUpperCase = s -> System.out.println(s.toUpperCase());
printUpperCase.accept("hello"); // Output: HELLO

3.3. Supplier

• Purpose: Represents a supplier of results, providing a way to generate or produce data without taking any input.
• Usage: Useful for lazy initialization, memoization, or providing default values.

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

example:

Supplier<Double> randomValue = () -> Math.random();
System.out.println(randomValue.get()); // Output: Random double value

3.4. Comparator

• Purpose: Represents a comparison function that defines how to order elements of a certain type.
• Usage: Essential for sorting and ordering collections based on custom criteria.

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

example:

Comparator<String> byLength = (s1, s2) -> Integer.compare(s1.length(), s2.length());
List<String> names = Arrays.asList("John", "Alice", "Mike");
names.sort(byLength);
System.out.println(names); // Output: [John, Mike, Alice]

4. Variables in Lambdas

With respect to lambdas variables can appear in three places: the parameter list, local variables declared inside the lambda body, and variables referenced from the lambda body. We will explore each one

4.1. Parameter List

Lambda expressions can have parameters similar to regular methods. These parameters are declared in the parameter list enclosed within parentheses ( ). Parameters in lambda expressions are analogous to method parameters and are used to pass values into the lambda body. These parameters can be declared with:

• their type explicitly
• using the var keyword
• in certain cases the type can be inferred by the compiler based on the context, so you can omit the type declaration

BiFunction<Integer, Integer, Integer> adder = (Integer a, Integer b) -> a + b;
BiFunction<Integer, Integer, Integer> adder = (var a, var b) -> a + b;
BiFunction<Integer, Integer, Integer> adder = (a, b) -> a + b;

All three forms are valid and can be used interchangeably. However, explicit type declaration can enhance readability and clarity, especially in complex lambda expressions or when dealing with multiple parameters of different types. On the other hand, using var or omitting the type declaration can reduce verbosity and make the code more concise.

4.2. Local Variables Inside the Lambda Body

In lambda expressions, the body can contain a block of code enclosed within curly braces {}. Inside this block, you can declare local variables just like you would in a regular Java method. These variables are local to the lambda expression and are only accessible within its scope.

BiFunction<Integer, Integer, Integer> adder = (a, b) -> {
    int result = a + b; // Local variable declared inside the lambda body
    return result;
};

int sum = adder.apply(3, 5);
System.out.println("Sum: " + sum); // Output: Sum: 8

4.3. Variables Referenced from Lambda Body

In lambda expressions, variables referenced from the lambda body can be categorized into three types based on their accessibility and how they are treated:

4.3.1. Instance Variables (Non-Local Variables)

• These are fields declared in the enclosing class where the lambda expression is defined.
• They are accessible inside the lambda body without any special treatment.

class Calculator {
    private int base;

    public Calculator(int base) {
        this.base = base;
    }

    public void calculate(int num) {
        // Lambda expression accessing instance variable 'base'
        BinaryOperator<Integer> operation = (x, y) -> x * y + base;

        // Applying the operation
        int result = operation.apply(num, 2);
        System.out.println("Result: " + result);
    }
}

4.3.2. Local Variables

• These are variables declared in the enclosing method or block where the lambda expression is defined.
• Lambda expressions can read the values of these variables, but they must be effectively final (i.e., their values should not change after being captured by the lambda).

public class Main {
    public static void main(String[] args) {
        final int threshold = 5; // Local variable

        IntConsumer consumer = value -> {
            if (value > threshold) {
                System.out.println(value);
            }
        };
    }
}

//The following code does not compile because threshold is not final

public class Main {
    public static void main(String[] args) {
        int threshold = 5; // Local variable
        threshold = 6;

        IntConsumer consumer = value -> {
            if (value > threshold) { //compiler error
                System.out.println(value);
            }
        };
    }
}

4.3.3. Method Parameters

• These are the parameters of the enclosing method.
• Lambda expressions can use these parameters to perform operations within the lambda body, but they must be effectively final

    public void calculate(final int num) {
        BinaryOperator<Integer> operation = (x, y) -> x * y + num;

        // Applying the operation
        int result = operation.apply(num, 2);
    }

//The following code does not compile because num is not final
    public void calculate(int num) {
        num++;
        BinaryOperator<Integer> operation = (x, y) -> x * y + num;

        // Applying the operation
        int result = operation.apply(num, 2);
    }

5. Common lamdas en functional interfaces

5.1. sort()

The sort method in Java’s List interface is used to sort the elements of the list according to the order induced by the specified Comparator. In Java 8 and later versions, List has a default method sort that takes a Comparator.

Here’s how you can use the sort method with a lambda expression to provide custom sorting logic:

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Create a list of strings
        List<String> words = new ArrayList<>();
        words.add("apple");
        words.add("banana");
        words.add("cherry");
        words.add("date");
        words.add("grape");

        // Sort the list of strings in descending order of length
        words.sort((s1, s2) -> Integer.compare(s2.length(), s1.length()));

        // Print the sorted list
        System.out.println("Sorted list in descending order of length:");
        for (String word : words) {
            System.out.println(word);
        }
    }
}

• We create a list of strings and populate it with some words.
• We use the sort method with a lambda expression to sort the strings in descending order of their lengths.
• The lambda expression (s1, s2) -> Integer.compare(s2.length(), s1.length()) acts as a Comparator. It compares the lengths of two strings (s1 and s2) and returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
• The sort method applies the lambda expression to compare elements during the sorting process.
• After sorting, we print the list to verify that the strings are sorted in descending order of length.

5.2. remove()

The removeIf method in Java’s List interface is a default method introduced in Java 8. It removes all elements from the list that satisfy the given predicate. The removeIf method takes a Predicate as its argument, which is a functional interface from the java.util.function package.

Here’s how you can use removeIf with a lambda expression:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Create a list of integers
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        numbers.add(40);
        numbers.add(50);

        // Remove all even numbers from the list
        numbers.removeIf(n -> n % 2 == 0); // Lambda expression as a Predicate

        // Print the updated list
        System.out.println("Updated list after removing even numbers:");
        for (int num : numbers) {
            System.out.println(num);
        }
    }
}

• We create a list of integers and populate it with some values.
• We use the removeIf method along with a lambda expression to remove all even numbers from the list.
• The lambda expression (n -> n % 2 == 0) acts as a Predicate, where n represents each element of the list. It returns true if the element is even (n % 2 == 0) and false otherwise.
• The removeIf method iterates over each element of the list and applies the lambda expression to determine whether to remove the element.
• After removing the even numbers, we print the updated list to verify the changes.

5.3. forEach()

The forEach method in Java’s Iterable interface is used to iterate over each element of the collection and perform an action specified by the Consumer interface. In Java 8 and later versions, Iterable has a default method forEach that takes a Consumer.

Here’s how you can use the forEach method with a lambda expression to specify the action to be performed on each element of the collection:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Create a list of integers
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        // Iterate over each element and print it
        numbers.forEach(num -> System.out.println("Number: " + num)); 
    }
}

• We create a list of integers and populate it with some numbers.
• We use the forEach method with a lambda expression to iterate over each element and print it.
• The lambda expression num -> System.out.println("Number: " + num) acts as a Consumer. It accepts an integer argument (num) and prints it to the console.
• The forEach method applies the lambda expression to each element of the list, executing the specified action for each element.