The difference is the following:
A lambda expression looks like
parameters -> expression
or
parameters -> { block }
where either the block returns a value - or it doesn't for a void-like behaviour.
In other words, a parameters -> expression lambda is equivalent to parameters -> { return expression; } if expression has a non-void type or to parameters -> { expression; } if expression has void type (such as System.out.printf()).
Your first version essentially uses an expression with a bit of overhead:
i -> i = i * 2 could be reduced to i -> i * 2, as the i = assignment is just unnecessary, because i disappears immediately afterwards without being used any further.
It is just like
Integer function(Integer i) {
i = i * 2;
return i;
}
or
Integer function(Integer i) {
return (i = i * 2);
}
which can be simplified to
Integer function(Integer i) {
return i * 2;
}
All these examples would match the interface UnaryOperator<Integer> which is a special case for Function<Integer, Integer>.
In contrast, you 2nd example is like
XY function(int i) {
i = i * 2;
}
which doesn't work:
- Either
XY is void (which would make a Consumer<Integer> which doesn't fit with .map())
- Or
XY is indeed Integer (then the return statement is missing).
Where is the need for that value (except to make the code compile)?
Well, .forEach(System.out::println); needs that value...
So, everything which can be converted to a Function<T, R> can be given to a .map() of a T stream, resulting in an R stream:
Stream.of(1, 2, 3).map(i -> i * 2)
Stream.of(1, 2, 3).map(i -> { return i * 2; })
turn the Integer you give into another Integer, giving you another Stream<Integer>. You notice that they are boxed?
Other ways would be
// turn a Stream<Integer> to an IntStream with a
// int applyAsInt(Integer i) aka ToIntFunction<Integer>
Stream.of(1, 2, 3).mapToInt(i -> i * 2)
Stream.of(1, 2, 3).mapToInt(i -> { return i * 2; })
// turn an IntStream to a different IntStream with a
// int applyAsInt(int i) aka IntUnaryOperator
IntStream.of(1, 2, 3).map(i -> i * 2)
IntStream.of(1, 2, 3).map(i -> { return i * 2; })
// turn an IntStream to a Stream<Integer> with a
// Integer apply(int i) aka IntFunction<Integer>
IntStream.of(1, 2, 3).mapToObj(i -> i * 2)
IntStream.of(1, 2, 3).mapToObj(i -> { return i * 2; })
All these examples have in common that they get a value and produce a value of either the same or a different type. (Note how these examples use AutoBoxing and AutoUnboxing as needed.)
OTOH, everything which can be converted to a Consumer<T> can be given to a .map() of a T stream, which can be any form of lambda which produces a void expression:
.forEach(x -> System.out.println(x))
.forEach(x -> { System.out.println(x); }) // no return as you cannot return a void expression
.forEach(System.out::println) // shorter syntax for the same thing
.forEach(x -> { }) // just swallow the value
With that in mind, it is easy to see that a lambda with void expression type cannot be given to .map(), and a lambda with a non-void type cannot be given to forEach().
