This rule raises an issue when a lambda expression uses block notation while expression notation could be used.

Why is this an issue?

The right-hand side of a lambda expression can be written in two ways:

1. Expression notation: the right-hand side is as an expression, such as in (a, b) → a + b
2. Block notation: the right-hand side is a conventional function body with a code block and an optional return statement, such as in (a, b) → {return a + b;}

By convention, expression notation is preferred over block notation. Block notation must be used when the function implementation requires more than one statement. However, when the code block consists of only one statement (which may or may not be a return statement), it can be rewritten using expression notation.

This convention exists because expression notation has a cleaner, more concise, functional programming style and is regarded as more readable.

Exceptions

This rule does not flag block-form lambdas in the following cases:

• Multiline body — if the opening { and closing } are on different lines, a block form is kept for readability.
• Spring JDBC query() with a single-parameter lambda — converting such a lambda to an expression form may silently change overload resolution.
• MethodHandle.invoke() / MethodHandle.invokeExact() — these are signature-polymorphic methods. Converting such lambdas to an expression form changes the inferred return type, which can cause a WrongMethodTypeException at runtime.

entries.forEach(e -> { // Compliant, multiline body
  System.out.println(e.getKey() + ": " + e.getValue());
});

// Compliant, expression form would resolve to ResultSetExtractor instead of RowCallbackHandler
jdbcTemplate.query("SELECT id, cnt FROM t", rs -> { map.merge(rs.getLong("id"), rs.getLong("cnt"), Long::sum); });

process(() -> { handle.invokeExact(); }); // Compliant, signature-polymorphic invocation stays void

How to fix it

• If the code block consists only of a return statement, replace the code block with the argument expression from the return statement.
• If the code block consists of a single statement that is not a return statement, replace the code block with that statement.

Code examples

Noncompliant code example

(a, b) -> { return a + b; } // Noncompliant, replace code block with expression

Compliant solution

(a, b) -> a + b             // Compliant

Noncompliant code example

x -> { System.out.println(x+1); } // Noncompliant, replace code block with statement

Compliant solution

x -> System.out.println(x+1)    // Compliant