Using parameters inside lambda expression

Question

I am wondering why I can use the method parameters i and j inside the lambda and where they are stored in the anonymous class. I also noticed the compiler automatically makes these parameters final. What's going on here in the background I am not aware of?

public class Editor {

    public interface Task {
        int edit();
    }

    static ArrayList<Task> tasks = new ArrayList<>();

    public static void add(int i, int j) {
        tasks.add(() -> i + j);
    }


    public static void main(String[] args) {
        add(4,5);
        System.out.println(tasks.get(0).edit());
    }

}

Answer 1

I also noticed the compiler automatically makes these parameters final.

Actually that is not correct.

What happens is that the compiler determines that the parameters are effectively final at the point in the code where the lambda expression is created. Effectively final means that the code (as written) does not change the values.

See JLS 15.27.2 for the precise wording.

Since they are effectively final in your example, the compiler allows you to use i and j in the lambda. (If they weren't, you would get a compilation error!)

What actually happens is that the compiler (or more precisely, the compiler writer) reasons that since i and j cannot change, the compiled bytecodes can save the i and j values in synthetic fields of the object that represents the lambda. Later, when the lambda is called, it gets the values of i and j from those fields. That way, the compiled code doesn't need to worry that the stack frame containing the original i and j variables may have gone away.

Answer 2

You can use i and j, because effectively they are being instance variables.

You can think of your lambda as a much shorter equivalent of this implementation:

public class MyTask implements Task {

        private final int i;
        private final int j;

        public MyTask(int i, int j) {
            this.i = i;
            this.j = j;
        }

        @Override
        public int edit() {
            return this.i + this.j;
        }
}

Then instead of using lambda, you add you task to the list like so:

tasks.add(new MyTask(i, j));

As for second question, i believe this SO question should be good read on the topic. Also this one.