The local variable syntax for lambda parameters is the only language feature introduced in Java 11. In this tutorial, we’ll explore and use this new feature.
2. Local Variable Syntax for Lambda Parameters
One of the key features introduced in Java 10 was local variable type inference. It allowed the use of var as the type of the local variable instead of the actual type. The compiler inferred the type based on the value assigned to the variable.
However, we could not use this feature with lambda parameters. For example, consider the following lambda. Here we explicitly specify the types of the parameters:
(String s1, String s2) -> s1 + s2
We could skip the parameter types and rewrite the lambda as:
(s1, s2) -> s1 + s2
Even Java 8 supported this. The logical extension to this in Java 10 would be:
(var s1, var s2) -> s1 + s2
However, Java 10 did not support this.
Java 11 addresses this by supporting the above syntax. This makes the usage of var uniform in both local variables and lambda parameters.
Why would we want to use var for lambda parameters when we could simply skip the types?
One benefit of uniformity is that modifiers can be applied to local variables and lambda formals without losing brevity. For example, a common modifier is a type annotation:
(@Nonnull var s1, @Nullable var s2) -> s1 + s2
We cannot use such annotations without specifying the types.
There are a few limitations of using var in lambda.
For example, we cannot use var for some parameters and skip for others:
(var s1, s2) -> s1 + s2
Similarly, we cannot mix var with explicit types:
(var s1, String s2) -> s1 + s2
Finally, even though we can skip the parentheses in single parameter lambda:
s1 -> s1.toUpperCase()
we cannot skip them while using var:
var s1 -> s1.toUpperCase()
All of the above three usages will result in compilation error.
In this quick article, we explored this cool new feature in Java 11 and saw how we can use local variable syntax for lambda parameters.