Why lambda expressions in Java 8 requires variables used inside it to use "final" modifier, but not when using method reference?

Question

Consider following class:

class Foo<T> {

    void handle(T t) {
        System.out.println("handling " + t);
    }

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);

        Foo<Integer> f = new Foo<>();

        list.forEach(f::handle);             // compiles fine
        //list.forEach(obj -> f.handle(obj));// compilation error

        f = new Foo<>(); // reassign f

    }
}

Why do I get compilation error for obj -> f.handle(obj), but not for f::handle?

Um, both versions _should_ work without the `final` modifier. (It still has to be effectively final, though.) — Louis Wasserman, Dec 22 '14 at 19:46
Yes, the question was why the second version does not require the final modifier. — Mateus Viccari, Dec 22 '14 at 19:48
@MateusViccari I tried to simplify your question. Feel free to rollback my edit if you don't feel that it is what you wanted to ask. — Pshemo, Dec 22 '14 at 20:30
I like that https://stackoverflow.com/a/33053161/94687 accepted answer there to a similar question more because it is a bit more detailed and clear. Although that question is more recent (young), and this one is older.So, if closing duplicates, this one should survive according to its age. — imz -- Ivan Zakharyaschev, Jul 29 '21 at 19:27

score 15 · Accepted Answer · answered Dec 22 '14 at 21:00

15

Those are two different constructs that are doing two different things. In the first case, you are getting the method reference of a specific object: this needs to be done only once, after which the JVM has its own reference (so effectively final) to the object f and can call the handle method. In the second case, at each call the JVM has to resolve the f reference and it thus complains that f must be final. You could easily write code that sets f to null while the forEach is running and thus cause a NPE.

answered Dec 22 '14 at 21:00

Giovanni Botta

9,626
5
51
94

I made a little example which might highlight the difference between lambda expression and method reference: http://pastebin.com/4W0ivi7U – vbezhenar Dec 22 '14 at 21:10
You could also write `final Foo f = null;` and cause a NPE. That doesn't explain why `f` has to be effectively final. – a better oliver Dec 22 '14 at 21:26
Some guy just changed my entire question, so i don't know if you're talking about "his" question or mine. But i think i got your point, thanks. – Mateus Viccari Dec 22 '14 at 23:43
@MateusViccari I'm the "some guy". Sorry if I changed your question too much, was trying to prevent it from being closed as "unclear what you are asking" by posting example which would let us easily *reproduce* your problem. If I misunderstood problem you are facing consider posting another question, but this time provide more info with code which will let others reproduce error described in question. – Pshemo Dec 23 '14 at 01:01
@zeroflagL Yes you could, but from the compiler's perspective, the important is that the reference does not change and thus the program has a more deterministic behavior. The compiler won't stop you from willingly shooting yourself in the foot! :) – Giovanni Botta Dec 23 '14 at 15:47

score 3 · Answer 2 · answered Dec 23 '14 at 04:12

To add an illustration to Giovanni's answer, we can highlight the difference between f::handle and obj -> f.handle(obj) if we replace f with a method call:

static Set<String> f() {
    System.out.println("  f() called");
    return new HashSet<>();
}

public static void main(String[] args) {
    List<String> empty = Collections.emptyList();
    List<String> strings = Arrays.asList("foo", "bar");

    System.out.println("method reference, no invocations");
    empty.forEach(f()::add);

    System.out.println("method reference, 2 invocations");
    strings.forEach(f()::add);

    System.out.println("lambda, no invocations");
    empty.forEach(str -> f().add(str));

    System.out.println("lambda, 2 invocations");
    strings.forEach(str -> f().add(str));
}

Output:

method reference, no invocations
  f() called
method reference, 2 invocations
  f() called
lambda, no invocations
lambda, 2 invocations
  f() called
  f() called

So, as you see .forEach(f()::add) will evaluate f() right away and then call add(...) on the result as many times as the lambda is called.

On the other hand, str -> f().add(str) will not do anything upfront but will call f() every time the lambda is invoked.

Why lambda expressions in Java 8 requires variables used inside it to use "final" modifier, but not when using method reference?

2 Answers2

Linked

Related