Limitations of Method References
You'll learn: when method references fall short and you must use lambda expressions instead.
The Core Idea
Method references are wonderfully concise—when they fit. But they can only point to a single existing method that matches the functional interface's signature exactly. If you need to add extra logic, combine operations, manipulate parameters, or pass additional arguments, method references simply won't work. That's when lambdas are essential.
When Method References Cannot Help
1. Adding Extra Logic If you need to perform any operation beyond calling the method directly:
// Method reference won't work - need to transform first
list.forEach(str -> System.out.println(str.toUpperCase()));
2. Passing Additional Arguments Method references can't inject extra parameters:
// Need to pass a fixed prefix
list.forEach(str -> logMessage("INFO", str));
3. Combining Multiple Operations When logic involves more than one method call:
// Multiple steps required
list.stream()
.map(s -> s.trim().toLowerCase())
.forEach(System.out::println);
4. Parameter Manipulation If you need to rearrange, duplicate, or ignore parameters:
BiFunction<Integer, Integer, Integer> swap = (a, b) -> someMethod(b, a);
5. Conditional Logic
Any if statement or ternary operator requires a lambda:
list.removeIf(str -> str != null && str.isEmpty());
Think of It This Way
A method reference is like speed dial—it works great when you're calling exactly one person. But if you need to check the time first, call two people, or say something before connecting, you need to dial manually (use a lambda).
Key Takeaway:
Method references are limited to direct, one-to-one method calls; use lambdas when you need additional logic, parameter manipulation, or multi-step operations.