final和effectively final的区别

如果您可以将final修饰符添加到局部变量中，则该变量就是“有效地final”。Lambda表达式可以访问静态变量、实例变量、有效的final方法参数和有效的final局部变量。
此外，“有效的final”变量是一个值从未更改但未声明为final关键字的变量。
来源：OCP：Oracle认证专业Java SE 8程序员II学习指南，Jeanne Boyarsky，Scott Selikoff 来源：从控制结构到对象（第6版），Tony Gaddis开始使用Java 此外，不要忘记 final 的含义，即它在第一次使用之前只被初始化一次。

声明一个变量为final或不声明为final，但保持其有效的final状态，可能会导致（取决于编译器）不同的字节码。

让我们看一个小例子：

    public static void main(String[] args) {
        final boolean i = true;   // 6  // final by declaration
        boolean j = true;         // 7  // effectively final

        if (i) {                  // 9
            System.out.println(i);// 10
        }
        if (!i) {                 // 12
            System.out.println(i);// 13
        }
        if (j) {                  // 15
            System.out.println(j);// 16
        }
        if (!j) {                 // 18
            System.out.println(j);// 19
        }
    }

主方法main的相应字节码（Java 8u161，Windows 64位）：

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1
       1: istore_1
       2: iconst_1
       3: istore_2
       4: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       7: iconst_1
       8: invokevirtual #22                 // Method java/io/PrintStream.println:(Z)V
      11: iload_2
      12: ifeq          22
      15: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
      18: iload_2
      19: invokevirtual #22                 // Method java/io/PrintStream.println:(Z)V
      22: iload_2
      23: ifne          33
      26: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
      29: iload_2
      30: invokevirtual #22                 // Method java/io/PrintStream.println:(Z)V
      33: return

相应的行号表：

 LineNumberTable:
   line 6: 0
   line 7: 2
   line 10: 4
   line 15: 11
   line 16: 15
   line 18: 22
   line 19: 26
   line 21: 33

当我们查看第12、13和14行的源代码时，字节码中并没有出现。这是因为i是true，并且不会改变其状态。因此，这段代码是无法访问的（更多信息请参见answer）。由于同样的原因，第9行的代码也缺失了。不必评估i的状态，因为它肯定是true。

另一方面，尽管变量j是有效地最终的，但处理方式不同。没有应用这样的优化。j的状态被评估了两次。无论j是否为有效地最终，字节码都是相同的。

有效终态变量是一个本地变量，它：

1. 没有被定义为 final
2. 只被赋值一次。

而 final 变量是一个被声明为：

1. 带有 final 关键字的变量。

在Java中，有三种类型的最终变量声明。
1. 隐式声明的最终变量
有三种隐式声明的最终变量。
- 在接口中声明的字段。 - 作为try-with-resource语句中的资源声明的局部变量。 - 多重try子句中的异常参数。
2. 显式声明的最终变量
这些是使用"final"关键字声明的变量。
3. 有效最终变量
如果满足以下条件，变量被视为有效最终变量：
- 在语句中声明的局部变量，并且其声明符具有初始化程序，或者通过模式声明的局部变量，并且应遵循以下规则： 1. 没有使用"final"进行声明。 2. 从未出现过赋值操作。 3. 从未出现在前缀或后缀递增或递减运算符的操作数中。
例如：在语句中声明的局部变量，并且其声明符具有初始化程序。

List<String> ls = Arrays.asList("A", "B", "C");

for (Iterator<String> iterator = ls.iterator(); iterator.hasNext();) {
  String s = (String) iterator.next();
  System.out.println(s);
}

这里变量iterator是有效地终态，因为它遵循上述规则。

注意：如果变量是有效地终态，也可以使用final关键字声明。

List<String> ls = Arrays.asList("A", "B", "C");

for (final Iterator<String> iterator = ls.iterator(); iterator.hasNext();) {
  String s = (String) iterator.next();
  System.out.println(s);
}

ex: 模式声明的局部变量。

public String getStringfromObj(Object o){

    if (o instanceof String s && s.startsWith("Java")) { // can be declared as final String s
      return s;
    }
    
    return "";
}

ii. 在语句中声明的局部变量，稍后初始化。应遵循以下规则。

1. 不使用 final 声明
2. 在明确赋值之前和之后不作为值分配出现
3. 不作为前缀或后缀递增或递减运算符的操作数出现

示例：

List<String> ls = Arrays.asList("A", "B", "C");
int k; // can be declared as final int k
    
    if ((k = ls.size()) > 0) {
      System.out.println(k);
}

iii. 具有初始化程序的声明符的方法、构造函数、lambda表达式或异常参数。

然而，从Java SE 8开始，本地类可以访问封闭块的局部变量和参数，这些变量和参数是final或有效final的。这并不是从Java 8开始的，我很久以前就使用了这个功能。 在Java 8之前，以下代码是合法的：

String str = ""; //<-- not accesible from anonymous classes implementation
final String strFin = ""; //<-- accesible 
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
         String ann = str; // <---- error, must be final (IDE's gives the hint);
         String ann = strFin; // <---- legal;
         String str = "legal statement on java 7,"
                +"Java 8 doesn't allow this, it thinks that I'm trying to use the str declared before the anonymous impl."; 
         //we are forced to use another name than str
    }
);