Basic Lambda Conversion: Removing Boilerplate
You'll learn how to replace verbose anonymous class syntax with concise lambda expressions when implementing functional interfaces.
The Core Idea
In the previous lessons, you've seen anonymous classes used to implement functional interfaces—interfaces with just one abstract method. While anonymous classes work perfectly, they contain a lot of repetitive boilerplate code: the new InterfaceName() part, curly braces, the method signature, and often explicit return statements.
Lambda expressions let you strip away all that ceremony and focus only on what the method does. Think of it like giving directions: instead of saying "I am now going to tell you the following directions, which consist of: turn left," you just say "turn left."
The Transformation
Here's the pattern for converting a simple anonymous class to a lambda:
Before (Anonymous Class):
Comparator<String> comp = new Comparator<String>() {
@Override
public int compare(String a, String b) {
return a.length() - b.length();
}
};
After (Lambda):
Comparator<String> comp = (a, b) -> a.length() - b.length();
Notice what disappeared:
new Comparator<String>()@Override- The method name
compare - The parameter types
String - Curly braces and
return(for single expressions)
The compiler infers all of this from context. You keep only the essential parts: parameters and the implementation.
Why This Matters
Lambda expressions dramatically reduce visual clutter for common patterns like Comparators, Runnables, and event handlers. Your code becomes more readable because the signal-to-noise ratio improves—the actual logic stands out instead of hiding in boilerplate.
Key Takeaway: Lambda expressions replace anonymous class implementations of functional interfaces by removing boilerplate, keeping only parameters and the method body.