Java Lambda and Functional Interfaces Exercises: 25 Coding Problems with Solutions

@FunctionalInterface
interface StringProcessor {
    String process(String s);
}

public class Main {
    public static void main(String[] args) {
        // Usage:
        StringProcessor toUpperCase = s -> s.toUpperCase();
        String result = toUpperCase.process("hello world");
        System.out.println(result);
    }
}Code language: Java (java)

Explanation:

• @FunctionalInterface: Marks the interface as having exactly one abstract method, so the compiler can verify it is a valid target for a lambda.
• s -> s.toUpperCase(): Lambda expression implementing process(), taking a String parameter and returning it converted to uppercase.
• toUpperCase.process("hello world"): Invokes the lambda body just like calling any interface method.
• Alternative: You could write the lambda with an explicit block body, s -> { return s.toUpperCase(); }, though the expression form is shorter for a single statement.

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

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob", "Diana"));

        // Usage:
        names.sort((a, b) -> b.compareTo(a));
        System.out.println(names);
    }
}Code language: Java (java)

Explanation:

• names.sort((a, b) -> b.compareTo(a)): Supplies a Comparator<String> as a lambda, where a and b represent any two elements being compared.
• b.compareTo(a): Reverses the natural ordering of String.compareTo(), producing descending alphabetical order.
• in-place sorting: List.sort() mutates the original list directly rather than returning a new one.
• Alternative: You could use names.sort(Comparator.reverseOrder()) for the same result without writing the comparison logic yourself.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Usage:
        Thread thread = new Thread(() -> System.out.println("Running in a separate thread"));
        thread.start();
        thread.join();
    }
}Code language: Java (java)

Explanation:

• () -> System.out.println(...): Lambda implementing Runnable‘s single abstract method run(), taking no arguments since run() itself takes none.
• new Thread(() -> ...): Passes the lambda directly to the Thread constructor, which normally expects a Runnable object.
• thread.join(): Waits for the thread to finish before main() exits, guaranteeing the output is printed.
• Alternative: You could still write out an anonymous Runnable class with new Runnable() { public void run() {...} }, but the lambda form removes that boilerplate entirely.

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        // Usage:
        MathOperation addition = (a, b) -> a + b;
        MathOperation subtraction = (a, b) -> a - b;
        MathOperation multiplication = (a, b) -> a * b;

        System.out.println("Addition: " + addition.operate(10, 5));
        System.out.println("Subtraction: " + subtraction.operate(10, 5));
        System.out.println("Multiplication: " + multiplication.operate(10, 5));
    }
}Code language: Java (java)

Explanation:

• (a, b) -> a + b: Lambda implementing operate() to return the sum of its two parameters.
• MathOperation addition = ...: Assigns the lambda to a variable typed as the functional interface, so it can be passed around and invoked like any object.
• addition.operate(10, 5): Calls the lambda body with the given arguments, exactly as if operate() had been implemented by a full class.
• Alternative: You could write a single method that accepts a MathOperation parameter and applies it, letting the caller decide which lambda to pass in at call time.

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        // Usage:
        Predicate<String> isEmpty = s -> s == null || s.isEmpty();

        System.out.println(isEmpty.test(""));
        System.out.println(isEmpty.test(null));
        System.out.println(isEmpty.test("hello"));
    }
}Code language: Java (java)

Explanation:

• Predicate<String>: A built-in functional interface with a single abstract method test(T t) that returns a boolean.
• s == null || s.isEmpty(): Checks for null first using short-circuit evaluation, so isEmpty() is never called on a null reference.
• isEmpty.test(...): Invokes the lambda for each input string, returning true for both an empty string and a null reference.
• Alternative: You could use s == null || s.isBlank() instead, which also treats a string containing only whitespace as empty.

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

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

        // Usage:
        numbers.forEach(n -> System.out.println(n * 2));
    }
}Code language: Java (java)

Explanation:

• numbers.forEach(...): Calls the given lambda once for every element in the list, in iteration order.
• n -> System.out.println(n * 2): Lambda implementing Consumer<Integer>, doubling each element before printing it.
• no return value: forEach() expects a Consumer, whose single abstract method accept() returns void, matching the lambda’s void body.
• Alternative: You could use a stream instead, numbers.stream().map(n -> n * 2).forEach(System.out::println), which separates the doubling step from the printing step.

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

class Employee {
    private final String name;
    private final double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return name + ": " + salary;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<>(List.of(
                new Employee("Alice", 75000),
                new Employee("Bob", 55000),
                new Employee("Charlie", 65000)
        ));

        // Usage:
        employees.sort((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employees);
    }
}Code language: Java (java)

Explanation:

• (e1, e2) -> Double.compare(...): Lambda implementing Comparator<Employee>‘s compare() method, comparing two employees by their salary field.
• Double.compare(a, b): Returns a negative, zero, or positive value based on the natural ordering of the two doubles, exactly what sort() needs.
• employees.sort(...): Reorders the list in place using the comparator, from lowest salary to highest.
• Alternative: You could use employees.sort(Comparator.comparingDouble(Employee::getSalary)) for a shorter, method reference based version of the same comparator.

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class Main {

    public static List<Integer> filterNumbers(List<Integer> numbers, Predicate<Integer> condition) {
        List<Integer> result = new ArrayList<>();
        for (int number : numbers) {
            if (condition.test(number)) {
                result.add(number);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Usage:
        List<Integer> evenNumbers = filterNumbers(numbers, n -> n % 2 == 0);
        System.out.println("Even numbers: " + evenNumbers);
    }
}Code language: Java (java)

Explanation:

• Predicate<Integer> condition: Lets the method accept any single-argument boolean check as an argument, without knowing in advance what that check will be.
• condition.test(number): Evaluates the caller’s lambda against the current element.
• n -> n % 2 == 0: The specific lambda passed in at the call site, keeping only even numbers.
• Alternative: You could rewrite filterNumbers() using a stream, numbers.stream().filter(condition).collect(Collectors.toList()), which removes the manual loop and result list entirely.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "banana", "kiwi", "grape", "fig");

        // Usage:
        List<Integer> lengths = words.stream()
                                      .map(String::length)
                                      .collect(Collectors.toList());
        System.out.println("Lengths: " + lengths);
    }
}Code language: Java (java)

Explanation:

• words.stream(): Converts the list into a Stream<String> that supports functional style operations.
• .map(String::length): Applies String‘s length() method to every element, producing a new stream of Integer values.
• .collect(Collectors.toList()): Gathers the transformed stream elements back into a concrete List<Integer>.
• Alternative: You could write the mapping step as a lambda instead of a method reference, .map(s -> s.length()), which behaves identically but is slightly more verbose.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(11, 22, 33, 44, 55, 66, 77, 88);

        // Usage:
        List<Integer> evenNumbers = numbers.stream()
                                            .filter(n -> n % 2 == 0)
                                            .collect(Collectors.toList());
        System.out.println("Even numbers: " + evenNumbers);
    }
}Code language: Java (java)

Explanation:

• numbers.stream(): Converts the list into a stream so intermediate operations like filter() can be chained.
• .filter(n -> n % 2 == 0): Keeps only the elements where the modulo check evaluates to true, discarding everything else.
• .collect(Collectors.toList()): Terminates the stream and gathers the surviving elements into a new List<Integer>.
• Alternative: You could use numbers.stream().filter(n -> n % 2 == 0).toList() (Java 16+) instead of Collectors.toList(), which returns an unmodifiable list with less boilerplate.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        // Usage:
        int sumOfSquares = numbers.stream()
                                   .map(n -> n * n)
                                   .reduce(0, Integer::sum);
        System.out.println("Sum of squares: " + sumOfSquares);
    }
}Code language: Java (java)

Explanation:

• .map(n -> n * n): Squares every element in the stream before reduction takes place.
• .reduce(0, Integer::sum): Starts from an identity value of 0 and repeatedly combines it with each squared value using addition.
• Integer::sum: Method reference equivalent to the lambda (a, b) -> a + b.
• Alternative: You could use .mapToInt(n -> n * n).sum() instead, which avoids boxing to Integer and returns a primitive int directly.

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Person {
    private final int id;
    private final String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Person> people = List.of(
                new Person(1, "Alice"),
                new Person(2, "Bob"),
                new Person(3, "Charlie")
        );

        // Usage:
        Map<Integer, String> idToName = people.stream()
                .collect(Collectors.toMap(Person::getId, Person::getName));
        System.out.println(idToName);
    }
}Code language: Java (java)

Explanation:

• Collectors.toMap(Person::getId, Person::getName): Builds a map by applying the key function and value function to every stream element.
• Person::getId / Person::getName: Method references supplying the key and value extraction logic without writing explicit lambdas.
• resulting Map<Integer, String>: Keys come from each person’s ID, values come from their name.
• Alternative: You could pass a third merge function argument to toMap(), (existing, replacement) -> existing, to handle the case where two people share the same ID instead of throwing an exception.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(5, 3, 8, 3, 1, 5, 9, 1);

        // Usage:
        List<Integer> result = numbers.stream()
                                       .distinct()
                                       .sorted()
                                       .collect(Collectors.toList());
        System.out.println(result);
    }
}Code language: Java (java)

Explanation:

• .distinct(): Removes duplicate elements, keeping just one copy of each distinct value.
• .sorted(): Arranges the remaining elements in ascending natural order, since Integer implements Comparable.
• operation order: Removing duplicates before sorting means sorted() has fewer elements to process.
• Alternative: You could reverse the order and call .sorted().distinct(), which produces the same final result here, though sorting first can be less efficient on very large inputs since it still has to process every duplicate.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> languages = List.of("Java", "Python", "C++");

        // Usage:
        String joined = languages.stream()
                                  .collect(Collectors.joining(", "));
        System.out.println(joined);
    }
}Code language: Java (java)

Explanation:

• Collectors.joining(", "): Concatenates the stream elements into one String, placing ", " between each pair of adjacent elements.
• no trailing delimiter: joining() only inserts the delimiter between elements, so the final string never ends with one.
• languages.stream().collect(...): The standard pattern for turning a stream back into a single collected result.
• Alternative: You could pass a prefix and suffix too, Collectors.joining(", ", "[", "]"), to wrap the joined result in brackets like a formatted list.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<List<Integer>> nestedNumbers = List.of(
                List.of(1, 2, 3),
                List.of(4, 5),
                List.of(6, 7, 8, 9)
        );

        // Usage:
        List<Integer> flatList = nestedNumbers.stream()
                                               .flatMap(List::stream)
                                               .collect(Collectors.toList());
        System.out.println(flatList);
    }
}Code language: Java (java)

Explanation:

• nestedNumbers.stream(): Produces a Stream<List<Integer>>, where each element is itself a list.
• .flatMap(List::stream): Converts each inner list into a stream of its elements, then flattens all of those streams into a single stream.
• difference from map(): map() would produce a Stream<Stream<Integer>>, while flatMap() merges the nested streams into one flat stream automatically.
• Alternative: You could achieve the same flattening with a nested for loop that adds every inner element to a new ArrayList, though that removes the declarative, single-pipeline style of the stream version.

import java.util.List;
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("Apple", "Banana", "Java", "Jasmine", "Kiwi");

        // Usage:
        Optional<String> firstJWord = words.stream()
                                            .filter(word -> word.startsWith("J"))
                                            .findFirst();
        System.out.println(firstJWord.orElse("No match found"));
    }
}Code language: Java (java)

Explanation:

• .filter(word -> word.startsWith("J")): Narrows the stream down to only the words starting with “J”.
• .findFirst(): Returns an Optional<String> containing the first surviving element, or an empty Optional if none matched.
• firstJWord.orElse("No match found"): Safely reads the value out of the Optional without risking a NullPointerException.
• Alternative: You could use .anyMatch(word -> word.startsWith("J")) if you only needed to know whether a match exists, without needing the actual matching word.

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Usage:
        Map<Boolean, List<Integer>> partitioned = numbers.stream()
                .collect(Collectors.partitioningBy(n -> n % 2 == 0));

        System.out.println("Even: " + partitioned.get(true));
        System.out.println("Odd: " + partitioned.get(false));
    }
}Code language: Java (java)

Explanation:

• Collectors.partitioningBy(n -> n % 2 == 0): Splits the stream into exactly two groups based on whether each element satisfies the predicate.
• partitioned.get(true): Retrieves the list of elements for which the predicate returned true, in this case the even numbers.
• always two keys: Unlike groupingBy(), partitioningBy() always produces both a true and a false entry, even if one of the lists ends up empty.
• Alternative: You could use Collectors.groupingBy(n -> n % 2 == 0) instead, which behaves similarly here but is meant for grouping by an arbitrary classifier rather than a strict two-way split.

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("Apple", "Banana", "Avocado", "Cherry", "Almond");

        Predicate<String> startsWithA = word -> word.startsWith("A");

        // Usage:
        List<String> filtered = words.stream()
                                      .filter(startsWithA.negate())
                                      .collect(Collectors.toList());
        System.out.println(filtered);
    }
}Code language: Java (java)

Explanation:

• Predicate<String> startsWithA = word -> word.startsWith("A"): Stores a reusable rule for matching strings that start with “A”.
• startsWithA.negate(): Returns a new predicate that flips the result of the original, so filter() keeps only strings the original predicate rejects.
• .filter(startsWithA.negate()): Removes every string that starts with “A”, leaving the rest.
• Alternative: You could write the negated logic directly as a new lambda, word -> !word.startsWith("A"), instead of calling negate() on the original predicate.

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(4, 8, 11, 12, 15, 18, 20, 25);

        Predicate<Integer> isGreaterThanTen = n -> n > 10;
        Predicate<Integer> isEven = n -> n % 2 == 0;

        // Usage:
        List<Integer> result = numbers.stream()
                                       .filter(isGreaterThanTen.and(isEven))
                                       .collect(Collectors.toList());
        System.out.println(result);
    }
}Code language: Java (java)

Explanation:

• isGreaterThanTen.and(isEven): Builds a new Predicate that only returns true when both the original predicate and isEven both return true for the same element.
• short-circuit evaluation: and() stops checking as soon as the first predicate returns false, so isEven is never evaluated for numbers 10 or below.
• .filter(isGreaterThanTen.and(isEven)): Applies the combined condition directly inside the stream pipeline.
• Alternative: You could combine the two conditions inside a single lambda instead, n -> n > 10 && n % 2 == 0, though keeping them as separate named predicates makes each rule easier to reuse and test on its own.

import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> numericStrings = List.of("123", "45", "678", "9");

        Function<String, Integer> parseToInt = Integer::parseInt;

        // Usage:
        List<Integer> numbers = numericStrings.stream()
                                               .map(parseToInt)
                                               .collect(Collectors.toList());
        System.out.println(numbers);
    }
}Code language: Java (java)

Explanation:

• Function<String, Integer> parseToInt = Integer::parseInt: Stores a reusable transformation rule using a method reference instead of a lambda.
• .map(parseToInt): Applies that transformation to every element in the stream, converting each numeric string into its Integer value.
• Function<T, R>: The general purpose functional interface for any single-argument transformation, with apply() as its single abstract method.
• Alternative: You could inline the transformation directly as .map(Integer::parseInt) without a separate named variable, which works identically here since it is only used once.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> doubleValue = n -> n * 2;
        Function<Integer, Integer> addThree = n -> n + 3;

        // Usage:
        Function<Integer, Integer> combined = doubleValue.andThen(addThree);
        int result = combined.apply(5);
        System.out.println("Result: " + result);
    }
}Code language: Java (java)

Explanation:

• doubleValue.andThen(addThree): Returns a composed Function that first applies doubleValue, then passes that output into addThree.
• combined.apply(5): Runs doubleValue.apply(5) to get 10, then addThree.apply(10) to get 13.
• execution order: andThen() always executes the calling function first and the argument function second, the opposite of compose().
• Alternative: You could use addThree.compose(doubleValue) instead, which produces the exact same composed behavior since compose() runs its argument first and the calling function second.

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<List<String>> listFactory = ArrayList::new;

        // Usage:
        List<String> newList = listFactory.get();
        newList.add("first item");
        System.out.println(newList);
    }
}Code language: Java (java)

Explanation:

• Supplier<List<String>> listFactory = ArrayList::new: Stores a constructor reference that produces a brand new ArrayList each time it runs.
• listFactory.get(): Calls the Supplier‘s single abstract method, creating and returning a fresh, empty list.
• no input arguments: Unlike Function or Predicate, Supplier takes nothing in and only produces an output, matching what a factory method needs.
• Alternative: You could write the lambda explicitly as () -> new ArrayList<>(), which behaves identically to the ArrayList::new constructor reference.

import java.util.Random;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Random random = new Random();
        Supplier<Integer> randomNumber = () -> random.nextInt(100) + 1;

        // Usage:
        System.out.println(randomNumber.get());
        System.out.println(randomNumber.get());
        System.out.println(randomNumber.get());
    }
}Code language: Java (java)

Explanation:

• () -> random.nextInt(100) + 1: Lambda implementing Supplier<Integer>, generating a new random value between 1 and 100 every time it runs.
• randomNumber.get(): Triggers the lambda body again on each call, so the returned value is never cached or reused.
• shared Random instance: Reusing the same Random object across calls avoids the overhead of creating a new one every time.
• Alternative: You could use ThreadLocalRandom.current().nextInt(1, 101) inside the lambda instead of a shared Random field, which avoids needing to manage the Random instance yourself.

import java.util.List;
import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        List<String> messages = List.of("Server started", "User logged in", "Cache cleared");

        Consumer<String> logMessage = message -> System.out.println("Logged: " + message);

        // Usage:
        messages.forEach(logMessage);
    }
}Code language: Java (java)

Explanation:

• Consumer<String> logMessage = message -> System.out.println("Logged: " + message): Stores a reusable action that prefixes and prints any given string.
• messages.forEach(logMessage): Calls the Consumer‘s accept() method once for every message in the list.
• separation of concerns: Defining the Consumer separately from forEach() lets the same logging behavior be reused elsewhere without duplicating the print logic.
• Alternative: You could inline the lambda directly inside forEach(), messages.forEach(message -> System.out.println("Logged: " + message)), which skips the named variable if the Consumer is only used once.

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> scores = new LinkedHashMap<>();
        scores.put("Alice", 85);
        scores.put("Bob", 92);
        scores.put("Charlie", 78);

        BiConsumer<String, Integer> printMapping = (key, value) ->
                System.out.println(key + " directly maps to " + value);

        // Usage:
        scores.forEach(printMapping);
    }
}Code language: Java (java)

Explanation:

• BiConsumer<String, Integer> printMapping: Stores a two-argument action, matching the key and value types stored in the map.
• (key, value) -> System.out.println(...): Lambda implementing accept(), receiving both the key and the value for a single map entry.
• scores.forEach(printMapping): Iterates the map and calls the BiConsumer once for every key-value pair, in insertion order since a LinkedHashMap is used.
• Alternative: You could iterate manually with a for loop over scores.entrySet() and print each Map.Entry directly, though Map.forEach() with a BiConsumer avoids handling the Map.Entry object yourself.