Java generics allow us to define classes, interfaces, and methods that can work with different types of objects while maintaining type safety. Lambda expressions, introduced in Java 8, provide a concise way to represent anonymous functions. Combining lambda expressions with generics can lead to powerful and expressive code. In this article, we will explore how to use lambda expressions in Java generics.
1. Using Functional Interfaces
Functional interfaces are interfaces that have exactly one abstract method. They are often used as the basis for lambda expressions. To use lambda expressions in conjunction with generics, we can define our own functional interfaces.
@FunctionalInterface
interface MyFunction<T> {
void operate(T t);
}
The MyFunction interface is a functional interface that takes a generic type T and defines a single abstract method operate. We can now use this interface in generic code with lambda expressions.
2. Passing Lambda Expressions as Arguments
One common use case for lambda expressions in generics is to pass them as arguments to methods or constructors. This allows us to define behavior on-the-fly.
class MyClass<T> {
private MyFunction<T> function;
MyClass(MyFunction<T> function) {
this.function = function;
}
void performOperation(T t) {
function.operate(t);
}
}
In the MyClass example, we have a constructor that takes a MyFunction<T> object as an argument. This allows us to pass a lambda expression when creating an instance of MyClass. We can then call the performOperation method to execute the lambda expression.
3. Using Lambda Expressions with Built-in Functional Interfaces
Java provides several built-in functional interfaces, such as Predicate, Consumer, Function, etc. These interfaces are often used with lambda expressions to perform common operations on collections. We can also use them in conjunction with generics.
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// Using Predicate interface
Predicate<Integer> isEven = (n) -> n % 2 == 0;
List<Integer> evenNumbers = numbers.stream()
.filter(isEven)
.collect(Collectors.toList());
// Using Consumer interface
Consumer<Integer> printNumber = (n) -> System.out.println(n);
numbers.forEach(printNumber);
In this example, we use the Predicate interface to filter even numbers from a list and the Consumer interface to print each number. We can easily reuse these functional interfaces with different types thanks to generics.
Conclusion
Lambda expressions provide a concise and readable way to represent anonymous functions, and when combined with generics, they become even more powerful. By defining our own functional interfaces or using built-in functional interfaces, we can easily pass lambda expressions as arguments and perform various operations on different types of objects. This allows for more flexible and expressive code.
References: