Once you understand what a lambda expression is, the next step is learning its syntax. The syntax is intentionally compact, but a few rules determine when parentheses, parameter types, braces, and the return keyword are required.
The good news is that you do not need to memorize dozens of special cases. If you understand the basic structure and how Java infers types, most lambda expressions become easy to read and write.
Basic Lambda Syntax
(parameters) -> expression
A lambda expression has two main sides. The left side contains the parameters, and the right side contains the operation. The arrow operator -> separates them.
Important: A lambda expression cannot be used by itself as a standalone Java statement. It needs a target type, normally a functional interface, that defines the expected parameter and return types.
Lambda Syntax with No Parameters
When a lambda does not receive any parameters, you must use empty parentheses.
() -> System.out.println("Hello Java");
Here, there are no input values, so the parameter list is represented by ().
For example:
@FunctionalInterface
interface Message {
void show();
}
public class Main {
public static void main(String[] args) {
Message message = () -> System.out.println("Welcome to Java");
message.show();
}
}
The lambda provides the implementation of the show() method. Since show() has no parameters, the lambda also has no parameters.
Lambda Syntax with One Parameter
A lambda with one parameter can be written without parentheses.
name -> System.out.println(name);
Parentheses are also valid:
(name) -> System.out.println(name);
Both forms represent the same behavior. For a single parameter, omitting parentheses is often preferred because it keeps the expression concise.
Lambda Syntax with Multiple Parameters
When a lambda has two or more parameters, parentheses are required.
(a, b) -> a + b
For example:
@FunctionalInterface
interface Calculator {
int calculate(int a, int b);
}
public class Main {
public static void main(String[] args) {
Calculator addition = (a, b) -> a + b;
System.out.println(addition.calculate(10, 20));
}
}
The two parameters correspond to the two parameters declared by the functional interface method.
Parameter Types in Lambda Expressions
Java can usually infer lambda parameter types from the target functional interface.
Calculator addition = (a, b) -> a + b;
Because calculate() expects two integers, Java understands that a and b are integers.
You can also specify the types explicitly:
Calculator addition = (int a, int b) -> a + b;
Both forms are valid. In most straightforward cases, allowing Java to infer the types produces cleaner code.
Rule for Explicit Parameter Types
If you explicitly specify the type of one lambda parameter, you must specify the types of all parameters.
Calculator addition = (int a, int b) -> a + b;
This is valid because both parameter types are declared.
The following form is invalid:
Calculator addition = (int a, b) -> a + b;
You cannot mix explicitly declared and inferred parameter types within the same lambda parameter list.
Expression Body
When the lambda contains one expression, braces are optional.
number -> number * number
The value of the expression becomes the result of the lambda.
@FunctionalInterface
interface Square {
int calculate(int number);
}
public class Main {
public static void main(String[] args) {
Square square = number -> number * number;
System.out.println(square.calculate(5));
}
}
The expression number * number produces the return value automatically.
Block Body
When a lambda contains multiple statements, use braces.
number -> {
int result = number * number;
return result;
}
A block-bodied lambda follows normal statement rules. If the functional interface method returns a value, the lambda must explicitly return that value.
Expression Body vs Block Body
| Form | Example | Return Rule |
|---|---|---|
| Expression body | n -> n * n | Expression value is returned automatically |
| Block body | n -> { return n * n; } | Explicit return is required when a value is returned |
| Void block | n -> { System.out.println(n); } | No return value is required |
Lambda with a Void Return Type
A lambda can implement a method that returns void.
@FunctionalInterface
interface Printer {
void print(String message);
}
public class Main {
public static void main(String[] args) {
Printer printer = message -> System.out.println(message);
printer.print("Java Lambda");
}
}
Because the method does not return a value, the lambda only needs to perform the required operation.
Lambda with a Block and No Return Value
Printer printer = message -> {
System.out.println("Message: " + message);
System.out.println("Processing completed.");
};
Multiple statements can be placed inside the block without using return when the functional interface method has a void return type.
Lambda with a Return Value
Suppose the functional interface method returns an integer.
@FunctionalInterface
interface Operation {
int execute(int value);
}
An expression-bodied lambda can return the result directly:
Operation operation = value -> value * 10;
The equivalent block-bodied version is:
Operation operation = value -> {
return value * 10;
};
A common mistake is writing a return statement in an expression-bodied lambda.
Operation operation = value -> return value * 10;
This is invalid syntax. Use either an expression without return or a block with an explicit return.
Parentheses Rules
| Parameters | Valid Syntax |
|---|---|
| No parameters | () -> expression |
| One parameter | x -> expression |
| One parameter with parentheses | (x) -> expression |
| Multiple parameters | (x, y) -> expression |
| Explicit parameter types | (int x, int y) -> expression |
Using Lambdas with Collections
One of the most useful places to learn lambda syntax is with collections.
import java.util.*;
public class Main {
public static void main(String[] args) {
List<String> names = Arrays.asList(
"Ravi",
"Anita",
"Amit",
"Priya"
);
names.forEach(name -> System.out.println(name));
}
}
The forEach() method expects an operation to perform on every element. The lambda provides that operation.
Using Lambdas for Filtering
import java.util.*;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(5, 10, 15, 20, 25);
numbers.stream()
.filter(number -> number > 10)
.forEach(number -> System.out.println(number));
}
}
The lambda passed to filter() receives each number and produces a boolean result. Only numbers for which the condition is true continue through the stream.
Using Lambdas for Sorting
import java.util.*;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>(
Arrays.asList(40, 10, 30, 20)
);
numbers.sort((a, b) -> a - b);
System.out.println(numbers);
}
}
The lambda defines how two elements should be compared. This is a good example of how lambda syntax can make a small piece of behavior immediately visible.
Nested Logic Inside a Lambda
A lambda can contain conditional logic when a block body is used.
number -> {
if (number >= 18) {
return "Adult";
}
return "Minor";
}
This is valid when the target functional interface expects a result compatible with String.
Variable Capture
A lambda can access variables from its surrounding scope, but local variables used by the lambda must be final or effectively final.
public class Main {
public static void main(String[] args) {
int limit = 10;
java.util.function.Predicate<Integer> test =
number -> number > limit;
System.out.println(test.test(15));
}
}
The variable limit is effectively final because its value is never changed after initialization.
Remember: If a local variable is captured by a lambda, you cannot later change that variable's value.
Common Syntax Mistakes
- Forgetting the arrow operator between parameters and the body.
- Using parentheses incorrectly for multiple parameters.
- Mixing explicit and inferred parameter types.
- Using return without braces in an expression-bodied lambda.
- Forgetting the semicolon when the lambda assignment is part of a statement.
- Trying to modify a local variable captured by the lambda.
Best Practices
- Prefer the shortest syntax that remains clear.
- Allow Java to infer parameter types when the target type is obvious.
- Use expression bodies for simple operations.
- Use block bodies when multiple statements improve readability.
- Avoid turning lambdas into large blocks of business logic.
Interview Insight
A common interview question is: "What is the difference between an expression-bodied and block-bodied lambda?" The key answer is that an expression body can return its expression value implicitly, while a block body uses braces and requires an explicit return when the target method returns a value.
Quick Revision
| Concept | Syntax | Key Rule |
|---|---|---|
| No parameter | () -> expression | Empty parentheses are required |
| One parameter | x -> expression | Parentheses may be omitted |
| Multiple parameters | (x, y) -> expression | Parentheses are required |
| Expression body | x -> x * 2 | Result is implicit |
| Block body | x -> { return x * 2; } | Explicit return is required for a value |
| Explicit types | (int x, int y) -> x + y | All parameter types must be declared |
Final Takeaway
Lambda syntax becomes much easier once you see it as a simple pattern: parameters on the left, an arrow in the middle, and behavior on the right. Use empty parentheses for no parameters, optional parentheses for one inferred parameter, required parentheses for multiple parameters, and braces when your lambda needs multiple statements. Mastering these few rules gives you the foundation needed to work confidently with Java's functional interfaces and Stream API.