Java Lambda Expressions Examples: 3 Practical Use Cases

Understanding Java Lambda Expressions

Java lambda expressions provide a clear and concise way to represent a single method interface using an expression. Introduced in Java 8, they enable you to treat functionality as a method argument, which can lead to more readable and maintainable code. Below are three practical examples that demonstrate different use cases of lambda expressions in Java.

Example 1: Filtering a List of Strings

Context

In this example, we will use a lambda expression to filter a list of strings based on their length. This is particularly useful when dealing with collections of data where you want to isolate certain elements that meet specific criteria.

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

public class FilterExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

        List<String> longNames = names.stream()
                                       .filter(name -> name.length() > 3)
                                       .collect(Collectors.toList());

        System.out.println(longNames); // Output: [Alice, Charlie, David]
    }
}

Notes

• The filter() method takes a predicate (a functional interface) which is implemented using a lambda expression.
• The stream() method allows us to process the list in a functional manner.

Example 2: Sorting a List of Integers

Context

This example demonstrates how to sort a list of integers in descending order using a lambda expression. Sorting is a common operation in data manipulation that can be elegantly implemented with lambdas.

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

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

        List<Integer> sortedNumbers = numbers.stream()
                                              .sorted((a, b) -> b.compareTo(a))
                                              .collect(Collectors.toList());

        System.out.println(sortedNumbers); // Output: [5, 4, 3, 2, 1]
    }
}

Notes

• The sorted() method allows us to define a custom comparator using a lambda expression.
• This example showcases how flexible and straightforward sorting can be with the use of lambda expressions.

Example 3: Performing Actions on List Elements

Context

In this example, we will demonstrate how to use a lambda expression to perform an action on each element of a list, such as printing each element. This is useful when you need to apply an operation to every item in a collection.

import java.util.Arrays;
import java.util.List;

public class ActionExample {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");

        fruits.forEach(fruit -> System.out.println(fruit));
    }
}

Notes

• The forEach() method is used to iterate over the elements of the collection, and the lambda expression defines the action to be performed on each element.
• This approach enhances readability and reduces boilerplate code.

Each of these examples illustrates the versatility of Java lambda expressions, showing how they can simplify code and improve clarity in various scenarios.