Krdytkyu

It's better to express this behavior in the code:

List<Integer> list= new ArrayList<>();

Stream.of(1,2,3).forEach(i -> list.add(1));  // COMPILES



Stream.of(1,2,3).forEach(i -> true);  // DOES NOT COMPILE!

forEach(...) accepts Consumer, but why does the first example compile if List interface has following signature boolean add(E e)?

Though you might be looking just for

Stream.of(1,2,3).forEach(list::add); // adding all to `list`

why does the first example compile if List interface has following
signature boolean add(E e)

Primarily because the return type of the method is ignored in the first call. This is what it expands to:

Stream.of(1,2,3).forEach(new Consumer<Integer>() {

    @Override

    public void accept(Integer i) {

        list.add(1); // ignored return type

    }

});  // COMPILES

On the other hand, the other lambda representation is more like a Predicate(which is also a FunctionalInterface) represented as returning true always from its test method. If you even try to represent it as a Consumer, it might just look like

Stream.of(1,2,3).forEach(new Consumer<Integer>() {

    @Override

    public void accept(Integer i) {

        return true; // you can correlate easily now why this wouldn't compile 

    }

});  // DOES NOT COMPILE!

The Special Void-Compatibility Rule (JLS) says that a lambda that returns void may accept a statement whose return is non-void. In this case, the return is discarded. hence this compiles.

Stream.of(1,2,3).forEach(i -> list.add(1)); // return value of add is ignored

To word it a bit differently by quoting Java-8 in Action book:

If a lambda has a statement expression as its body, it’s compatible
with a function descriptor that returns void (provided the parameter
list is compatible too). For example, both of the following lines are
legal even though the method add of a List returns a boolean and not
void as expected in the Consumer context (T -> void):

// Predicate has a boolean return

 Predicate<String> p = s -> list.add(s); 

// Consumer has a void return 

Consumer<String> b = s -> list.add(s);

As for the second example, this is explicitly trying to return a boolean where it's not expected hence not possible.

Stream.of(1,2,3).forEach(i -> true);  

in other words:

Stream.of(1,2,3).forEach(i -> {return true;});

As you already know forEach takes a Consumer so attempting to "explicitly" return a boolean should & will yield a compilation error.

forEach() as a Consumer as the one and only parameter therefore you need to give an implemention of the method accept() which returns void so on the second example you're implementing a method with the given assinature static boolean method(int).

forEach(Consumer<? super T> action) is asking for an action (some process to be done with the element). It needs a method name, not a variable. The return type of the given method doesn't matter.

Performs an action for each element of this stream.

...

Parameters

• action - a non-interfering action to perform on the
  elements

^{Stream (Java Platform SE 8)}