Introduction
In Java, lambda expressions and method references are both features introduced in Java 8 to support functional programming. While both serve the purpose of simplifying the way we write functional interfaces, there are specific scenarios where each is more suitable. This guide explains when to use a lambda expression and when to use a method reference.
What is a Lambda Expression?
A lambda expression is a concise way to represent an anonymous function that implements a functional interface (an interface with a single abstract method). It has the following syntax:
(parameters) -> { body of the function }
Example of a Lambda Expression
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));
What is a Method Reference?
A method reference is a shorthand for calling a method. It is represented using the :: operator and can be used when a lambda expression calls an existing method without any modification.
Example of a Method Reference
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println);
Key Differences
| Aspect | Lambda Expression | Method Reference |
|---|---|---|
| Readability | Useful for custom logic; may be longer. | Shorter and more concise when applicable. |
| Usage Complexity | Allows custom implementations within the body. | Only references an existing method. |
| Preferred Scenario | When additional logic is needed inside the lambda. | When a method is directly reusable. |
Types of Method References
- Static Method Reference:
ClassName::staticMethod
Function<Integer, String> converter = String::valueOf; System.out.println(converter.apply(123));
- Instance Method of a Particular Object:
instance::methodName
Consumer<String> printer = System.out::println;
printer.accept("Hello, World!");
- Instance Method of an Arbitrary Object of a Specific Type:
ClassName::instanceMethod
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.sort(String::compareToIgnoreCase);
- Constructor Reference:
ClassName::new
Supplier<List<String>> listSupplier = ArrayList::new;
List<String> list = listSupplier.get();
When to Use Lambda Expressions
- When you need to implement custom logic that cannot be achieved with an existing method.
- When the body of the function requires multiple statements.
- Example:
Runnable task = () -> {
System.out.println("Task started");
System.out.println("Task completed");
};
When to Use Method References
- When a method already exists that matches the required functional interface.
- To improve code readability by avoiding redundant lambda expressions.
- Example:
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println);
Summary
Use lambda expressions when you need custom logic or a concise way to implement a functional interface. Use method references when an existing method matches your functional interface’s requirements, as it enhances code readability and reduces boilerplate code. Both features complement each other and can be used interchangeably based on the specific scenario.