考虑：
List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
System.out.println(item);
}
如果不使用for each语法，等价的for循环会是什么样子？
当前回答
在Java5中添加的for each循环（也称为“增强的for循环”）相当于使用Java.util.Interator——这是一个语法糖。因此，在逐个按顺序读取每个元素时，应始终在迭代器上选择for each，因为它更方便和简洁。
对于每个
for (int i : intList) {
System.out.println("An element in the list: " + i);
}
迭代器
Iterator<Integer> intItr = intList.iterator();
while (intItr.hasNext()) {
System.out.println("An element in the list: " + intItr.next());
}
在某些情况下，您必须直接使用迭代器。例如，在使用For each时尝试删除元素可能会（将？）导致ConcurrentModificationException。
对于每个与For循环：基本区别
for循环和for each之间的唯一实际区别是，在可索引对象的情况下，您无权访问索引。需要基本for循环时的示例：
for (int i = 0; i < array.length; i++) {
if(i < 5) {
// Do something special
} else {
// Do other stuff
}
}
尽管您可以手动为每个创建单独的索引int变量，
int idx = -1;
for (int i : intArray) {
idx++;
...
}
…不建议这样做，因为变量范围并不理想，基本的for循环只是这个用例的标准和预期格式。
对于每个与For循环：性能
访问集合时，for each比基本for循环的数组访问快得多。然而，当访问数组时（至少是使用原始数组和包装数组时），通过索引访问的速度要快得多。
为基元int数组的迭代器和索引访问之间的差异计时
在访问int或Integer数组时，索引比迭代器快23-40%。这是本文底部测试类的输出，它将100个元素的原始int数组中的数字相加（a是迭代器，B是索引）：
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)
我还对Integer数组运行了这个，索引仍然是明显的赢家，但只快了18%到25%。
对于集合，迭代器比索引更快
然而，对于整数列表来说，迭代器显然是赢家。只需将测试类中的int数组更改为：
List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100});
并对测试函数进行必要的更改（int[]到List<Integer>，length到size（）等）：
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)
在一次测试中，它们几乎是等价的，但在集合中，迭代器获胜。
*这篇文章基于我在Stack Overflow上写的两个答案：
Java中for每个循环的用法和语法我应该使用迭代器还是forloop进行迭代？
更多信息：for-each循环和迭代器哪个更有效？
完整测试类
在阅读了关于堆栈溢出的问题后，我创建了一个比较类做任何两件事所需的时间：
import java.text.NumberFormat;
import java.util.Locale;
/**
<P>{@code java TimeIteratorVsIndexIntArray 1000000}</P>
@see <CODE><A HREF="https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java">https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java</A></CODE>
**/
public class TimeIteratorVsIndexIntArray {
public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);
public static final void main(String[] tryCount_inParamIdx0) {
int testCount;
// Get try-count from a command-line parameter
try {
testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
}
catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
throw new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
}
//Test proper...START
int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};
long lStart = System.nanoTime();
for(int i = 0; i < testCount; i++) {
testIterator(intArray);
}
long lADuration = outputGetNanoDuration("A", lStart);
lStart = System.nanoTime();
for(int i = 0; i < testCount; i++) {
testFor(intArray);
}
long lBDuration = outputGetNanoDuration("B", lStart);
outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
}
private static final void testIterator(int[] int_array) {
int total = 0;
for(int i = 0; i < int_array.length; i++) {
total += int_array[i];
}
}
private static final void testFor(int[] int_array) {
int total = 0;
for(int i : int_array) {
total += i;
}
}
//Test proper...END
//Timer testing utilities...START
public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
long lDuration = System.nanoTime() - l_nanoStart;
System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
return lDuration;
}
public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
long lDiff = -1;
double dPct = -1.0;
String sFaster = null;
if(l_aDuration > l_bDuration) {
lDiff = l_aDuration - l_bDuration;
dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
sFaster = "B";
}
else {
lDiff = l_bDuration - l_aDuration;
dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
sFaster = "A";
}
System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
return lDiff;
}
//Timer testing utilities...END
}
其他回答
每个习惯用法的Java只能应用于*Iterable类型的数组或对象。这个习惯用法是隐含的，因为它确实有迭代器支持。迭代器由程序员编程，通常使用整数索引或节点（取决于数据结构）来跟踪其位置。从理论上讲，它比常规的for循环慢，至少对于数组和列表等“线性”结构来说是这样，但它提供了更大的抽象性。
正如许多其他答案正确指出的那样，for each循环只是同一个旧for循环的语法糖，编译器将其转换为同一个老for循环。
javac（OpenJDK）有一个开关-XD printflat，它生成一个Java文件，去掉了所有语法糖。完整的命令如下所示：
javac -XD-printflat -d src/ MyFile.java
//-d is used to specify the directory for output java file
所以让我们去掉语法糖
为了回答这个问题，我创建了一个文件，并为每个文件编写了两个版本，一个带有数组，另一个带有列表。我的Java文件如下所示：
import java.util.*;
public class Temp{
private static void forEachArray(){
int[] arr = new int[]{1,2,3,4,5};
for(int i: arr){
System.out.print(i);
}
}
private static void forEachList(){
List<Integer> list = Arrays.asList(1,2,3,4,5);
for(Integer i: list){
System.out.print(i);
}
}
}
当我用上面的开关编译这个文件时，我得到了以下输出。
import java.util.*;
public class Temp {
public Temp() {
super();
}
private static void forEachArray() {
int[] arr = new int[]{1, 2, 3, 4, 5};
for (/*synthetic*/ int[] arr$ = arr, len$ = arr$.length, i$ = 0; i$ < len$; ++i$) {
int i = arr$[i$];
{
System.out.print(i);
}
}
}
private static void forEachList() {
List list = Arrays.asList(new Integer[]{Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3), Integer.valueOf(4), Integer.valueOf(5)});
for (/*synthetic*/ Iterator i$ = list.iterator(); i$.hasNext(); ) {
Integer i = (Integer)i$.next();
{
System.out.print(i);
}
}
}
}
您可以看到，与其他语法糖（Autoboxing）一起，每个循环都被更改为简单循环。
我认为这会奏效：
for (Iterator<String> i = someList.iterator(); i.hasNext(); ) {
String x = i.next();
System.out.println(x);
}
Java for each循环（也称为增强的for循环）是for循环的简化版本。优点是编写的代码更少，管理的变量更少。缺点是无法控制步长值，也无法访问循环体中的循环索引。
当阶跃值是简单的1增量，并且您只需要访问当前循环元素时，最好使用它们。例如，如果需要在数组或集合中的每个元素上循环，而不在当前元素的前面或后面偷看。
没有循环初始化，没有布尔条件，步长值是隐式的，是一个简单的增量。这就是为什么它们被认为比常规for循环简单得多。
增强的for循环遵循以下执行顺序：
1） 环形体
2） 从步骤1开始重复，直到遍历了整个数组或集合
示例–整数数组
int [] intArray = {1, 3, 5, 7, 9};
for(int currentValue : intArray) {
System.out.println(currentValue);
}
currentValue变量保存在intArray数组中循环的当前值。请注意，没有显式的步长值——它总是以1为增量。
冒号可以被认为是“in”的意思。因此，增强的for循环声明声明：循环intArray并将当前数组int值存储在currentValue变量中。
输出：
1
3
5
7
9
示例–字符串数组
我们可以使用for each循环遍历字符串数组。循环声明声明：循环myStringsString数组并将当前String值存储在currentString变量中。
String [] myStrings = {
"alpha",
"beta",
"gamma",
"delta"
};
for(String currentString : myStrings) {
System.out.println(currentString);
}
输出：
alpha
beta
gamma
delta
示例–列表
增强的for循环还可以用于迭代java.util.List，如下所示：
List<String> myList = new ArrayList<String>();
myList.add("alpha");
myList.add("beta");
myList.add("gamma");
myList.add("delta");
for(String currentItem : myList) {
System.out.println(currentItem);
}
循环声明声明：循环myList List of Strings并将当前List值存储在currentItem变量中。
输出：
alpha
beta
gamma
delta
示例–集合
增强的for循环还可以用于迭代java.util.Set，如下所示：
Set<String> mySet = new HashSet<String>();
mySet.add("alpha");
mySet.add("alpha");
mySet.add("beta");
mySet.add("gamma");
mySet.add("gamma");
mySet.add("delta");
for(String currentItem : mySet) {
System.out.println(currentItem);
}
循环声明声明：循环mySet字符串集，并将当前Set值存储在currentItem变量中。注意，因为这是一个Set，所以不会存储重复的String值。
输出：
alpha
delta
beta
gamma
来源：Java中的循环–终极指南
它消除了所有基本的循环混乱，为代码增添了美感。它为您的代码提供了一个干净的外观，如下所示。
循环正常：
void cancelAll(Collection<TimerTask> list) {
for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
i.next().cancel();
}
用于每个：
void cancelAll(Collection<TimerTask> list) {
for (TimerTask t : list)
t.cancel();
}
for each是实现Iterator的集合上的构造。记住，您的集合应该实现Iterator；否则，不能将其用于每个。
以下行读作“for each TimerTask t in list”
for (TimerTask t : list)
每种情况下出现错误的可能性较小。您不必担心初始化迭代器或初始化循环计数器并终止它（在存在错误的地方）。
推荐文章
- 到底是什么导致了堆栈溢出错误?
- 为什么Android工作室说“等待调试器”如果我不调试?
- Java:路径vs文件
- ExecutorService，如何等待所有任务完成
- Maven依赖Servlet 3.0 API?
- 如何在IntelliJ IDEA中添加目录到应用程序运行概要文件中的类路径?
- getter和setter是糟糕的设计吗?相互矛盾的建议
- Android room persistent: AppDatabase_Impl不存在
- Java的String[]在Kotlin中等价于什么?
- Intellij IDEA上的System.out.println()快捷方式
- 使用Spring RestTemplate获取JSON对象列表
- Spring JPA选择特定的列
- URLEncoder不能翻译空格字符
- Java中的super()
- 如何转换JSON字符串映射<字符串，字符串>与杰克逊JSON
