Java Error: Java11 Local-Variable Syntax for Lambda Parameters (var keyword) error, how to handle and avoid

Java has introduced a new keyword var in the latest version Java11, which can replace type names that need to be explicitly declared, thereby simplifying the code and improving readability. However, when using Lambda expressions, the var keyword sometimes triggers a Local-Variable Syntax for Lambda Parameters error. This article will introduce the cause of this error, and how to deal with and avoid it.

Why does this error occur?

Before Java11, the formal parameters of a Lambda expression must explicitly declare their type. For example, a Lambda expression that receives a string and an integer might look like this:

BiFunction<String, Integer, String> func = (String str, Integer num) -> str.substring(num);

In Java 11, you can use the var keyword instead of the type name to make the above code more concise:

BiFunction<String, Integer, String> func = (var str, var num) -> str.substring(num);

However, if the compiler cannot infer its type when using the var keyword in a Lambda expression, a Local-Variable Syntax for Lambda Parameters error will occur.

For example, the following code will cause this error:

BiFunction<String, Integer, String> func = (var str, num) -> str.substring(num);

Among them, the second parameter num does not use the var keyword to explicitly declare the type.

How to deal with and avoid this error?

The way to deal with this error is very simple. You only need to explicitly specify the type for each formal parameter in the Lambda expression:

BiFunction<String, Integer, String> func = (var str, Integer num) -> str.substring(num);

In this way, the compiler The type of each formal parameter can now be correctly inferred, eliminating Local-Variable Syntax for Lambda Parameters errors.

But a better approach is to reduce the use of the var keyword in Lambda expressions as much as possible. In Java11, the var keyword is mainly used to simplify code and improve readability. However, in Lambda expressions, if used improperly, it will cause some problems. Therefore, when writing lambda expressions, it is best to explicitly specify the type for each formal parameter to avoid this error.

Summary

In Java11, the var keyword can simplify the code and improve readability. It can also bring a more concise form to the code when used in Lambda expressions. But at the same time, the var keyword will also bring some detailed problems, such as Local-Variable Syntax for Lambda Parameters errors. To avoid this error, we recommend minimizing the use of the var keyword in lambda expressions and explicitly specifying the type for each formal parameter if necessary. This can ensure the readability and correctness of the code and improve development efficiency.

The above is the detailed content of Java Error: Java11 Local-Variable Syntax for Lambda Parameters (var keyword) error, how to handle and avoid. For more information, please follow other related articles on the PHP Chinese website!