1. Introduction
Introduced in Java 8, lambda expressions provide a concise way to represent an instance of a functional interface — an interface with exactly one abstract method (also called a Single Abstract Method or SAM interface). Instead of writing a verbose anonymous inner class to implement interfaces like Runnable or Comparator, a lambda expression lets you express the same behavior in a compact, readable form.
Cricket analogy: Instead of naming a whole substitute fielder with a full contract just to catch one ball, a lambda is like Dhoni waving in a specialist just for the boundary catch, one job, no fuss, like implementing Runnable's single run() method inline.
Lambdas are heavily used with the Streams API, event handlers, and any API that expects a functional interface, significantly reducing boilerplate code and improving readability compared to the anonymous class style common before Java 8.
Cricket analogy: Just as Virat Kohli's shot selection is streamlined during a T20 chase compared to a slow Test innings, using lambdas with the Streams API to filter and map data cuts the ceremony that anonymous classes needed before Java 8.
2. Syntax
// General forms:
// (parameters) -> expression
// (parameters) -> { statements; }
// No parameters
Runnable r = () -> System.out.println("Running!");
// One parameter (parentheses optional for a single param)
Consumer<String> printer = s -> System.out.println(s);
// Multiple parameters
Comparator<String> byLength = (a, b) -> a.length() - b.length();
// Block body with multiple statements
Runnable task = () -> {
System.out.println("Step 1");
System.out.println("Step 2");
};
// Custom functional interface
@FunctionalInterface
interface Calculator {
int operate(int a, int b);
}
Calculator add = (a, b) -> a + b;3. Explanation
A lambda expression can only be used where a functional interface is expected, because the lambda's body becomes the implementation of that interface's single abstract method. The @FunctionalInterface annotation is optional but recommended on custom interfaces — it makes the compiler enforce that the interface has exactly one abstract method, catching accidental violations early.
Cricket analogy: Just as a designated bowler can only be brought on for an over within the match's laws, a lambda can only stand in where a functional interface is expected, and @FunctionalInterface is like the umpire enforcing that the role has exactly one job.
The java.util.function package provides several commonly used built-in functional interfaces so developers rarely need to declare their own: Predicate<T> (takes T, returns boolean — used for testing/filtering conditions), Function<T,R> (takes T, returns R — used for transformations), Consumer<T> (takes T, returns nothing — used for side effects like printing), and Supplier<T> (takes nothing, returns T — used for lazily producing values). Existing functional interfaces from before Java 8, like Runnable and Comparator, also work seamlessly with lambdas.
Cricket analogy: Predicate is like a selector's yes/no call on whether a batter makes the XI, Function is like a coach converting raw pace figures into a strategy, Consumer is like the scorer logging each run with no return, and Supplier is like the groundskeeper producing a fresh pitch report on demand.
Exam trap: a lambda expression can only target a functional interface with exactly ONE abstract method. If an interface has two or more abstract methods, you cannot assign a lambda to it — you would need an anonymous inner class instead. Default and static methods on the interface do not count toward this restriction.
4. Example
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class LambdaDemo {
@FunctionalInterface
interface Calculator {
int operate(int a, int b);
}
public static void main(String[] args) {
// Custom functional interface with a lambda
Calculator add = (a, b) -> a + b;
Calculator multiply = (a, b) -> a * b;
System.out.println("Sum: " + add.operate(3, 4));
System.out.println("Product: " + multiply.operate(3, 4));
// Built-in functional interface: Predicate
Predicate<Integer> isEven = n -> n % 2 == 0;
System.out.println("Is 10 even? " + isEven.test(10));
// Comparator with a lambda, used to sort a list
List<String> names = Arrays.asList("Charlie", "Amy", "Bob");
names.sort((s1, s2) -> s1.compareTo(s2));
System.out.println(names);
// Runnable with a lambda
Runnable greet = () -> System.out.println("Hello from a lambda thread task!");
greet.run();
}
}5. Output
Sum: 7
Product: 12
Is 10 even? true
[Amy, Bob, Charlie]
Hello from a lambda thread task!6. Key Takeaways
- A lambda expression's syntax is (parameters) -> expression or (parameters) -> { statements }.
- Lambdas can only implement functional interfaces — interfaces with exactly one abstract method.
- @FunctionalInterface is an optional but recommended annotation that enforces the single-abstract-method rule at compile time.
- Lambdas drastically reduce boilerplate compared to anonymous inner classes.
- java.util.function provides common ready-made functional interfaces: Predicate, Function, Consumer, Supplier.
- Existing interfaces like Runnable and Comparator also work directly with lambda expressions.
Practice what you learned
1. What is a functional interface?
2. Which built-in functional interface would you use to test a condition and return a boolean?
3. What does the Supplier<T> functional interface do?
4. What happens if you try to assign a lambda expression to an interface with two abstract methods?
5. What is the main benefit of using a lambda expression instead of an anonymous inner class for Runnable?
Was this page helpful?
You May Also Like
Interfaces in Java
Learn how Java interfaces define a contract of behavior, support multiple inheritance of type, and how default/static methods work since Java 8.
Multithreading in Java
Learn how Java creates and runs multiple threads concurrently using the Thread class and Runnable interface, and why start() and run() behave so differently.
Method Overriding in Java
Understand how Java subclasses override inherited methods, the rules governing overriding, and how runtime polymorphism resolves the actual method called.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics