Variable used in Lambda Expression Should be Final or Effectively Final

Anonymous Classes in Java are inner classes without a name, these are used in Java for override the method without actually creating a subclass. Anonymous Inner Class can use the local variable of other classes.

 
package org.wesome.java8;

abstract class Fuji {
    abstract void loveApple();
}

class Apple {
    public static void main(String[] args) {
        String appleName = "Fuji";

        Fuji fuji = new Fuji() {
            @Override
            void loveApple() {
                System.out.println("i love " + appleName + " apple.");
            }
        };

        fuji.loveApple();
    }
}

Anonymous Inner Class can use the local variable of the outer class but it cannot modify them. the below code will result in Compile Time Exception.

package org.wesome.java8;

abstract class Fuji {
    abstract void loveApple();
}

class Apple {
    public static void main(String[] args) {
        String appleName = "Fuji";

        Fuji fuji = new Fuji() {
            @Override
            void loveApple() {
                appleName = appleName.toUpperCase();
                System.out.println("i love " + appleName + " apple.");
            }
        };

        fuji.loveApple();
    }
}

Variable 'appleName' is accessed from within the inner class, needs to be final or effectively final

The Lambda Expression was introduced by Java to reduce the complexity of the Anonymous Inner Class, but it carries the same functionality as the Anonymous Inner Class, the Lambda Expression can access but cannot modify the Local Variables.

package org.wesome.java8;

import java.util.stream.IntStream;

class Apple {
    public static void main(String[] args) {
        int temp = 1;
        IntStream.rangeClosed(1, 5).forEach(i -> {
            System.out.println("value of temp is = " + temp);
        });
    }
}

The below code trying to update the temp variable in the lambda expression will result in a compilation error.

package org.wesome.java8;

import java.util.stream.IntStream;

class Apple {
    public static void main(String[] args) {
        int temp;
        IntStream.rangeClosed(1, 5).forEach(i -> {
            temp = i;
            System.out.println("value of i is = " + i);
        });
    }
}

Variable used in lambda expression should be final or effectively final

Since Lambda Expression is using the Local variable, it cannot be modified outside the Lambda Expression as well.

package org.wesome.java8;

import java.util.stream.IntStream;

class Apple {
    public static void main(String[] args) {
        int temp = 1;
        IntStream.rangeClosed(1, 5).forEach(i -> {
            System.out.println("value of temp is = " + temp);
        });
        temp = 2;
    }
}

local variables referenced from a lambda expression must be final or effectively final

Java Language Specification answers the reason for the above exception

Any local variable, formal parameter, or exception parameter used but not declared in a lambda expression must either be declared final or be effectively final (§4.12.4), or a compile-time error occurs where the use is attempted.

a

What is Final and Effective Final Variable

Final Variable: a variable that is declared with the final keyword cannot be modified and will have the same value throughout the application.

Effective Final Variable: a variable that is not explicitly declared with a final keyword but never gets modified throughout the application, although it's not declared as final since the value has not been modified hence compiler treats them just like final and can be termed as Effective Final.

If the Local Variable is just used but never gets updated inside the lambda expression hence no need to declare it as final.

so the question arises, why does Lambda Expression need a variable to be a final or effective final

The restriction to effectively final variables prohibits access to dynamically changing local variables, whose capture would likely introduce concurrency problems.