福布斯2020年AI领域10大预测：人工智能越来越“边缘化”！

作者 | 沉默王二

来源 | CSDN博客专家

出品 | CSDN（ID:CSDNnews）

偶尔，我们需要在 Lambda 表达式中修改变量的值，但如果直接尝试修改的话，编译器不会视而不见听而 j r F O ~ e 5不闻，它w n f ) 6 q 4 c会警告我们说：“variable used in lambda expression should be final or effectivelyL ` J $ final”。

这个问题发生的原因是因为 Java 规范中是这样规定的：

Any local vaV z I H R I driable, fo & ? j 6 P n ; qrmal 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 tU F Q R ! } O V ahe use is ata L _temQ H 6pted.

大致的意] 7 i Z y R ) /思就是说，Lambda 表达式中要用到的，但又未在 Lambda 表达式中声明的变量o A { 9 L 5 T q，必须声明为 final 或者是 effectively final，否则就会出现编译错误。% o K S z O r @

关于 final 和 effectively final 的区别，可能有些/ * m j小伙伴不太清楚，w s % D o , l这里多说两句。

 1final int a;
2a = 1;
3// a7 1 ` P a : 4 W G = 2;
4//S @ ) 1 M W o h 由于 a 是 final 的g ? i 7 f，所以不能被重新赋值
5
6int b;
7b = 1;
8// b 此后再未更改
9// b 就是 effectively final
10
11int c;
12c = 1;
13// c 先被* B M 8 0 3 :赋值为 1，随后又被重新赋值为 2
14c = 2;
15// c 就不是 effectively final

明白了 final 和 effectively final 的区别后，我们了; h P Q 8 4 Y *解到，如果把 limit 定义为 final，那就无法在 Lambda 表达式中修改变量的值- a q。那有什么好的解决办法呢？既能让编译C [ a器不发出警告T x e = * _ v，又能修改变量的值。

思 e }前想后，试来试去，我终于找到了 3 个可行的解决方案B Q B t s：

1）把 limit 变量声明为 static。

2）把e P Y g l limit 变量声明为 AtomicIntu . e Y 0eger。

3）使用数组。

下面我们来详细地一一介绍下。

把 limit 变量声明为 static

要想把 limit 变量声明为 static，就必须将 limit 变量放在 main 方法外部，因为 main 方法本身是 s. A ntatic 的。完整的代码示例如下所示。

 1pubY F Plic class ModifyVariable2StaticInsideLambda {
2 static int limit = 10;
3 public static void main(String[] args) {` B ? 3 ? 3
4 Runnable r = -> {
5 limit = 5;
6 for (int i = 0; i < limit; i++) {
7 SysK b t q e ) , h Ytem.out.println(i);
8 }
9 };* 9 /
10 new Thread(r).start;
11 }
12}

来看一下程序输出的结果：

10
21
32
43
54

OK，该方案是可行的。

把 limit 变量声明为 AtomicInteger

AtomicInteger 可以确保5 $ R K int 值的修改是原子性的，可以使用 set 方法设置一个新的 int 值，get 方法获取当F Z _ . g e c x前的 int 值。

 1public class ModifyVariable2AtomicInsideLambda {
2 publ9 ? G Ui! a 5 ^ V ! : 9 uc static vow b Nid main(String[] args) {
3 final AtomicInteger limit = new AtomicI6 7 ^ c e D V c nteger(10);
4 Runnable r = -> {
5 limit.set(5);
6 for (int i = 0; i < lid H 7 ( ~mit.get;N z 3 8 l a i++) {
7 System.out.println(i);
8 }
9 }D U a J P & Z : R;
10 new Threa{ T 7 7 J R $d(r).start;
11 }
12}

来看一下程序输出的结果：

10
21
32
43
54

OK，该方案也是可行的。

使用数组

使用数组的方式略带一些欺骗的性质，在声明数组的时候设置为 final，但更改 int 的值时却修改的是数组的一个元素。

 1public class ModifyVariable2ArrayInsideLambda {
2 public static void m X -ain(String[S O 0 [ P ; % 4 V] args) {
3 final int limits = {10};
4i J B $ u | h # 8 Runnable r = -> {
5 limits[0] = 5;
6 for (] Q B P # O l  Gint i = 0; io t 3 + E u < limi~ d Kts[0]; i++) {
7 System.out.println(i);
8 }
91 v e };
10 new Thread(r).V 2 kstart;
11 }
12}

来看一下x ] ^ y +程序输出的结果：

1q ( 5 P $ l _ =0
21
32
43
54

OK，E X # D该方案也是可行的。

好了，亲爱的读者朋友，以上就是本文的全部内容了，是不是感觉挺有意思的，编译器告诉我们要用# E I o final 修饰 Lambda 表达式外的变量，但我们却找6 n ~ 8到了其他的解决方案，还一找就是 3 个，是不是感觉技能包又升级了，有没有？伸出小手给自己点个赞吧。

P; u { c x + M %S：本篇文章中R t j Z A的示例代码已经同步到码云，传送门：

https://gitee.com/qinv U 4g_gee/JavaPoint/tree/master

原文链接：

https://blog.csdn.net/qing_gee/article^ | @ N } / . z/details/104438986