Lambda capturing vs non capturing

Question

Can you please explain why the first lambda is capturing and the second not.

   Runnable createLambdaWithCapture() {
      return System.out::println;
   }    
   Runnable createLambdaWithApparentCapture() {
        return () -> System.out.println();
   }

Answer 1

The first snippet is capturing because it evaluates System.out when the return statement is executed and captures the corresponding object reference to be used within its Runnable#run implementation.

The second snippet generates a Runnable instance that is not capturing because System.out is only evaluated once that instance's run method is invoked. It could have changed since the time the return statement was executed.

Answer 2

In the first method, System.out is evaluated immediately in the return statement.

The equivalent lambda would be as if you factored System.out out to a variable which then becomes an effectively final closure:

Runnable createLambdaWithCapture() {
    PrintWriter foo = System.out;
    return () -> foo.println(); // foo is captured and effectively final
}

In the second method, System.out (which is a static field) is not final and could be changed later at runtime. It is not invoked until Runnable::run is invoked.

System.out = aPrintStream;
Runnable runnable1 = createLambdaWithCapture();
Runnable runnable2 = createLambdaWithApparentCapture();
System.out = anotherPrintStream;
runnable1.run(); // prints to aPrintStream
runnable2.run(); // prints to anotherPrintStream