What is Effectively Final variable of Java 8? Example
Apart from the big three, Lambda expression, Stream API, and new Date and Time API, Java 8 has also introduced a new concept called the «effectively final» variable. A non-final local variable or method parameter whose value is never changed after initialization is known as effectively final. It’s very useful in the context of the lambda expression. If you remember, prior to Java 8, we cannot use a non-final local variable in an anonymous class. If you have to access a local variable ( a method parameter or a variable decreed in the method itself) in the Anonymous class, you have to make it final . This restriction is relaxed a bit with lambda coming up. Java designers have taken the need to make local variable final if it’s not changed once initialized.
This is really a good proactive step from them, they must have anticipated frequent use of lambda expressions as compared to the minimal use of Anonymous class and realized the pain to declare a local variable final every time in order to access it inside the lambda.
The rule has not changed, any local variable still has to be effectively final to be used inside lambda expression or anonymous inner class, it’s just that you don’t need to use the final keyword anymore, saving a few keystrokes.
If you don’t follow this then you will get the following error: «local variables referenced from a lambda expression must be final or effectively final». Let’s see some examples of effectively final variables with lambdas and anonymous class and how it makes the life of Java developers easy.
Btw, if you are not familiar with new Java 8 features like Effectively final variable then I suggest you first go through comprehensive and up-to-date Java courses from Udemy and Coursera. These are good resources to learn new Java features.
How to use Effective final variable in Java 8
The effective final variable is nothing but a gift from Java designers to us, Java developers. There is hardly any difference between a final local variable and an effectively final variable, once declared you cannot change the values of both of them.
If you do, the compiler will raise an error. Here is an example of using an effectively final variable in Java 8, if you run the same program with Java source 1.7, your program will not compile and give error «local variable nonFinal is accessed from within inner class; needs to be declared final» because nonFinal is a local variable but not final.
BTW, if you run the same program in Java 8 it will run fine and produce the output in the form of the print statement we have given.
Now in Java 8, if you try to reassign a new value to our non-final local variable, the compiler will again complain about the error «local variables referenced from an inner class must be final or effectively final» . This line is commented in our example, you can try by yourself by uncommenting it.
package test; /** * Java Program to demonstrate effectively final variable in Java 8. * * @author Javin Paul */ public class EffectiveFinalDemo public static void main(String args[]) String nonFinal = "I am non final local variable"; Runnable r = new Runnable() < @Override public void run() System.out.println("Using non-final local variable inside anonymous class in Java"); System.out.println("Value of non-final variable is : " + nonFinal); // compile time error - must be final or effective final // nonFinal = "Can I change non-final variable // inside anonymous class"; > >; Thread t = new Thread(r); t.start(); > >
Using non-final local variable inside anonymous class in Java Value of non-final variable is : I am non final local variable
public class EffectiveFinalWithLambda public static void main(String args[]) String effectiveFinal = "I am non final local variable"; Runnable r = () -> System.out.println("Value of effectively variable is : " + effectiveFinal); >; Thread t = new Thread(r); t.start(); > >
You can see that we can access «effectiveFinal» variable without any issue in the lambda expression. Now just try to assign this variable a new value before lambda, just to make it non-final and see what happens, you will receive an error «local variables referenced from a lambda expression must be final or effectively final» .
That’s all about what is the effectively final variable of Java 8 and how to use it in your Java program. Now it becomes one more thing to note about final variables in Java. Remember till Java 7, you cannot use a non-final local variable inside an anonymous class, but from Java 8 you can.
The concept of Effective final variables is only available from Java 8 onward. A variable is considered an effective final if it is not modified after initialization in the local block.
This means you can now use the local variable without the final keyword inside an anonymous class or lambda expression, provided they must be effectively final. In short, you can save some keystrokes while declaring local final variables intended to be used by the anonymous class.
There is no real difference between a final local variable and an effectively final variable of Java 8, once initialized you cannot change the value of both of them.
- 10 Good-Tutorials to Learn Java 8 (list)
- How to filter List in Java 8 using Predicates? (solution)
- Java 8 Comparator Example with Lambdas (example)
- 10 Java 7 Feature to revisit before you start with Java 8 (list)
- How to Read File in Java 8 in one line? (example)
- What is the default method in Java 8. (tutorial)
- How to use Map function in Java 8 (example)
- 10 Examples of Stream API in Java (examples)
- How to use Lambda Expression in Place of Anonymous class in Java 8 (solution)
- Java 8 tutorials and Books for FREE (resources)
- Are you ready for Java 8 Certification? (read more)
Final vs Эффективно Final в Java
Одна из самых интересных функций, представленных в Java 8, фактически финальная. Это позволяет нам не писать модификатор final для переменных, полей и параметров, которые эффективно обрабатываются и используются как final.
В этом руководстве мы рассмотрим происхождение этой функции и то, как она обрабатывается компилятором по сравнению с ключевым словом final . Кроме того, мы рассмотрим решение, которое можно использовать в отношении проблемного варианта использования эффективных конечных переменных.
2. Эффективно окончательное происхождение
Проще говоря, объекты или примитивные значения фактически являются окончательными, если мы не меняем их значения после инициализации . В случае объектов, если мы не меняем ссылку на объект, то она фактически является окончательной, даже если происходит изменение состояния объекта, на который делается ссылка.
До его введения мы не могли использовать нефинальную локальную переменную в анонимном классе . Мы по-прежнему не можем использовать переменные, которым присвоено более одного значения, внутри анонимных классов, внутренних классов и лямбда-выражений. Введение этой функции позволяет нам не использовать модификатор final для переменных, которые фактически являются final, что экономит нам несколько нажатий клавиш.
Анонимные классы являются внутренними классами, и они не могут получить доступ к переменным, не являющимся конечными или неэффективно конечными, или изменить их в своих объемлющих областях, как указано в JLS 8.1.3. То же ограничение применяется к лямбда-выражениям, так как доступ может привести к проблемам параллелизма.
3. Финал против фактически финала
Самый простой способ понять, действительно ли final переменная является final, — это подумать, позволит ли удаление ключевого слова final коду скомпилироваться и запуститься:
@FunctionalInterface public interface FunctionalInterface void testEffectivelyFinal(); default void test() int effectivelyFinalInt = 10; FunctionalInterface functionalInterface = () -> System.out.println("Value of effectively variable is : " + effectivelyFinalInt); > > Переназначение значения или изменение приведенной выше эффективной переменной final сделает код недействительным независимо от того, где это происходит.
3.1. Обработка компилятора
В JLS 4.12.4 указано, что если мы удалим модификатор final из параметра метода или локальной переменной без внесения ошибок времени компиляции, то он станет фактически окончательным. Более того, если мы добавим ключевое слово final к объявлению переменной в корректной программе, то оно станет фактически окончательным.
Компилятор Java не выполняет дополнительную оптимизацию для переменных final, в отличие от переменных final .
Давайте рассмотрим простой пример, в котором объявляются две переменные final String , но используются они только для конкатенации:
public static void main(String[] args) final String hello = "hello"; final String world = "world"; String test = hello + " " + world; System.out.println(test); > Компилятор изменит код, выполняемый в основном методе выше, на:
public static void main(String[] var0) String var1 = "hello world"; System.out.println(var1); > С другой стороны, если мы удалим модификаторы final , переменные будут считаться фактически окончательными, но компилятор не удалит их , поскольку они используются только для конкатенации.
4. Атомная модификация
Как правило, изменять переменные, используемые в лямбда-выражениях и анонимных классах, не рекомендуется . Мы не можем знать, как эти переменные будут использоваться внутри блоков методов. Их изменение может привести к неожиданным результатам в многопоточных средах.
У нас уже есть учебник, в котором объясняются лучшие практики использования лямбда-выражений , и еще один, в котором объясняются распространенные анти-шаблоны при их изменении . Но есть альтернативный подход, который позволяет нам изменять переменные в таких случаях, что обеспечивает потокобезопасность за счет атомарности.
Пакет java.util.concurrent.atomic предлагает такие классы, как AtomicReference и AtomicInteger . Мы можем использовать их для атомарного изменения переменных внутри лямбда-выражений:
public static void main(String[] args) AtomicInteger effectivelyFinalInt = new AtomicInteger(10); FunctionalInterface functionalInterface = effectivelyFinalInt::incrementAndGet; > 5. Вывод
В этом уроке мы узнали о наиболее заметных различиях между final и эффективно final переменными. Кроме того, мы предоставили безопасную альтернативу, позволяющую изменять переменные внутри лямбда-функций.