blocks|key|905712|text|想象一下速记看起来很像这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|905713|for+(Iterator<Integer>+iter+=+listOfNumbers.iterator();+iter.hasNext();+)
{
++++final+int+i+=+iter.next();
++++{
++++++++System.out.println(i);
++++}
}|code-block|syntax|javascript|905714|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Imagine that shorthand looks a lot like this:

<pre><code>for (Iterator&lt;Integer&gt; iter = listOfNumbers.iterator(); iter.hasNext(); )
{
 final int i = iter.next();
 {
 System.out.println(i);
 }
}
</code></pre>

blocks|key|905817|text|有关涉及的作用域规则的解释，请参阅@TravisG。使用像这样的final循环变量的唯一原因是，如果需要在匿名内部类中关闭它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|905818|import+java.util.Arrays;
import+java.util.List;

public+class+FinalLoop+{
++++public+static+void+main(String[]+args)+{
++++++++List<Integer>+list+=+Arrays.asList(new+Integer[]+{+0,1,2,3,4+});
++++++++Runnable[]+runs+=+new+Runnable[list.size()];

++++++++for+(final+int+i+:+list)+{
++++++++++++runs[i]+=+new+Runnable()+{
++++++++++++++++++++public+void+run()+{
++++++++++++++++++++++++System.out.printf("Printing+number+%25d\n",+i);
++++++++++++++++++++}
++++++++++++++++};
++++++++}

++++++++for+(Runnable+run+:+runs)+{
++++++++++++run.run();
++++++++}
++++}
}|code-block|syntax|javascript|905819|循环变量在执行时不在Runnable的作用域中，只有在实例化时才在Runnable的作用域中。如果没有final关键字，循环变量在最终运行时对Runnable是不可见的。即使是这样，对于所有的Runnables，它也是相同的值。|offset|length|style|CODE|905820|顺便说一句，大约10年前，您可能会看到在局部变量上使用final的速度有很小的提高(在一些很少的情况下)；很长一段时间都没有出现这种情况。现在，使用final的唯一原因是允许您使用这样的词法闭包。|905821|回复@mafutrct：|905822|当你写代码的时候，你是为两个读者写的。第一个是计算机，只要它在语法上是正确的，它就会对你所做的任何选择感到满意。第二个是给未来的读者(通常是你自己)，这里的目标是传达代码的“意图”，而不会模糊代码的“功能”。语言功能应该以习惯用法使用，并尽可能少地解释，以减少歧义。|905823|在循环变量的情况下，使用final可以用来传递两件事中的任何一件:单赋值；或者闭包。简单的循环扫描就会告诉您循环变量是否被重新赋值；然而，由于创建闭包时两个执行路径的交错，很容易遗漏闭包旨在捕获变量的信息。当然，除非您只使用final来表示捕获意图，这时读者就会明白正在发生的事情。|905824|entityMap^0|0|0|1F|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

See @TravisG for an explanation of the scoping rules involved. The only reason why you would use a final loop variable like this is if you needed to close over it in an anonymous inner class.

<pre><code>import java.util.Arrays;
import java.util.List;

public class FinalLoop {
 public static void main(String[] args) {
 List&lt;Integer&gt; list = Arrays.asList(new Integer[] { 0,1,2,3,4 });
 Runnable[] runs = new Runnable[list.size()];

 for (final int i : list) {
 runs[i] = new Runnable() {
 public void run() {
 System.out.printf("Printing number %d\n", i);
 }
 };
 }

 for (Runnable run : runs) {
 run.run();
 }
 }
}
</code></pre>

The loop variable is not in the scope of the Runnable when it is executed, only when it is instantiated.
Without the <code>final</code> keyword the loop variable wouldn't be visible to the Runnable when it is eventually run. Even if it was, it would be the same value for all the Runnables.

Btw, about 10 years ago you might have seen a very small speed improvement in using final on a local variable (in some rare occasions); that hasn't been the case for a long time. Now the only reason to use final is to permit you to use a lexical closure like this.

In answer to @mafutrct:

When you write code, you do so for two audiences. The first is the computer which, as long as it is syntactically correct, will be happy with whatever choices you make. The second is for a future reader (often yourself), here the goal is to communicate the 'intent' of the code, without obscuring the 'function' of the code. Language features should be used idiomatically with as few interpretations as possible to reduce ambiguity.

In the case of the loop variable, the use of final could be used to communicate either of two things: single-assignment; or, closure. A trivial scan of the loop will tell you if the loop variable is reassigned; however, due to the interleaving of two execution paths when creating a closure, it can be easy to miss that the closure intended to capture the variable. Unless, of course, you only ever use final to indicate intent-to-capture, at which point it becomes obvious to the reader that is what is happening.

I was surprised to see that the following Java code snippet compiled and ran:

<pre><code>for(final int i : listOfNumbers) {
 System.out.println(i);
}
</code></pre>

where listOfNumbers is an array of integers.

I thought final declarations got assigned only once. Is the compiler creating an Integer object and changing what it references?

How does "final int i" work inside of a Java for loop?

编译器

Java

我很惊讶地看到以下Java代码片段被编译并运行：for(final int i : listOfNumbers) {     System.out.println(i);}其中listOfNumbers是整数数组。我以为最终的声明只被赋值一次。编译器是否创建了一个Integer对象并更改了它引用的内容？

问"final int“在Java for循环中是如何工作的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问"final int“在Java for循环中是如何工作的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问"final int“在Java for循环中是如何工作的？
EN