考虑：
List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
System.out.println(item);
}
如果不为每个语法使用，等效的for循环会是什么样的？
答案 0 :(得分：1096)
for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
String item = i.next();
System.out.println(item);
}
请注意，如果需要在循环中使用i.remove();，或以某种方式访问实际的迭代器，则不能使用for ( : )惯用法，因为实际的迭代器只是推断出来的。
正如Denis Bueno所指出的，此代码适用于实现Iterable interface的任何对象。
此外，如果for (:)成语的右侧是array而不是Iterable对象，则内部代码使用int索引计数器并检查{{1相反。请参阅Java Language Specification。
答案 1 :(得分：467)
每个的构造对数组也有效。 e.g。
String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };
for (String fruit : fruits) {
// fruit is an element of the `fruits` array.
}
基本等同于
for (int i = 0; i < fruits.length; i++) {
String fruit = fruits[i];
// fruit is an element of the `fruits` array.
}
所以，总的来说：
[nsayer]以下是正在发生的事情的较长形式：
for(Iterator<String> i = someList.iterator(); i.hasNext(); ) { String item = i.next(); System.out.println(item); }请注意，如果您需要使用 i.remove（）;在你的循环中，或访问 你以某种方式实际的迭代器 不能使用for（：）成语，因为 实际的迭代器只是 推断。
这是nsayer的回答所暗示的，但是 值得注意的是OP的（...） 当“someList”是时，语法将起作用 任何实现的东西 java.lang.Iterable - 它没有 成为一个列表，或来自的一些集合 java.util中。甚至你自己的类型， 因此，可以与此一起使用 语法。
答案 2 :(得分：141)
foreach loop中添加的Java 5（也称为“增强for循环”）等同于使用java.util.Iterator - 它的语法糖用于相同的事情。因此，在逐个按顺序读取每个元素时，应始终在迭代器上选择foreach，因为它更方便，更简洁。
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());
}
在某些情况下，您必须直接使用Iterator。例如，尝试在使用foreach时删除元素可以（将？）导致ConcurrentModificationException。
foreach与for：基本差异 for和foreach之间唯一的实际区别在于，对于可索引对象，您无权访问索引。需要基本for循环的示例：
for(int i = 0; i < array.length; i++) {
if(i < 5) {
// Do something special
} else {
// Do other stuff
}
}
虽然您可以使用foreach手动创建单独的索引int变量，
int idx = -1;
for(int i : intArray) {
idx++;
...
}
不推荐使用，因为variable-scope并不理想，基本for循环只是此用例的标准格式和预期格式。
foreach与for：效果访问集合时，foreach significantly faster比基本for循环的数组访问权限Uses and syntax for for-each loop in Java。然而，当访问数组时 - 至少使用原始数据包和包装器数组 - 通过索引进行访问的速度要快得多。
在访问int或Integer数组时，索引比迭代器快23- 40 ％。以下是本文底部测试类的输出，它将100个元素的原始数组中的数字相加（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％。
对于List的{{1}}，迭代器是明显的赢家。只需将测试类中的int数组更改为：
Integers对测试函数进行必要的更改（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()在一次测试中，它们几乎相同，但是使用集合，迭代器会获胜。
*这篇文章基于我在Stack Overflow上写的两个答案：
更多信息： this question
在Stack Overflow上阅读{{3}}之后，我创建了这个比较 - 时间 - 任意两件事课：
[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)
答案 3 :(得分：125)
这是一个不承担Java迭代器知识的答案。它不太精确，但对教育很有用。
编程时，我们经常编写如下代码：
char[] grades = ....
for(int i = 0; i < grades.length; i++) { // for i goes from 0 to grades.length
System.out.print(grades[i]); // Print grades[i]
}
foreach语法允许这种常见模式以更自然，更少语法的方式编写。
for(char grade : grades) { // foreach grade in grades
System.out.print(grade); // print that grade
}
此外，此语法对于不支持数组索引但实现Java Iterable接口的Lists或Sets等对象有效。
答案 4 :(得分：36)
Java中的for-each循环使用底层迭代器机制。所以它与以下内容相同：
Iterator<String> iterator = someList.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
答案 5 :(得分：23)
在Java 8功能中，您可以使用它：
List<String> messages = Arrays.asList("First", "Second", "Third");
void forTest(){
messages.forEach(System.out::println);
}
First
Second
Third
答案 6 :(得分：22)
这是nsayer的回答所暗示的，但值得注意的是，当“someList”是实现java.lang.Iterable的任何时，OP的for（..）语法将起作用 - 它不会必须是一个列表，或java.util中的一些集合。因此，即使您自己的类型也可以使用此语法。
答案 7 :(得分：21)
foreach循环语法是：
for (type obj:array) {...}
示例：
String[] s = {"Java", "Coffe", "Is", "Cool"};
for (String str:s /*s is the array*/) {
System.out.println(str);
}
输出：
Java
Coffe
Is
Cool
警告：您可以使用foreach循环访问数组元素，但不能初始化它们。使用原始for循环。
警告：您必须将数组的类型与其他对象匹配。
for (double b:s) // Invalid-double is not String
如果您想编辑元素，请使用原始的for循环：
for (int i = 0; i < s.length-1 /*-1 because of the 0 index */; i++) {
if (i==1) //1 because once again I say the 0 index
s[i]="2 is cool";
else
s[i] = "hello";
}
现在，如果我们将s转储到控制台，我们得到：
hello
2 is cool
hello
hello
答案 8 :(得分：21)
如JLS中所定义for-each循环可以有两种形式：
如果表达式的类型是Iterable的子类型，则翻译为：
List<String> someList = new ArrayList<String>();
someList.add("Apple");
someList.add("Ball");
for (String item : someList) {
System.out.println(item);
}
// IS TRANSLATED TO:
for(Iterator<String> stringIterator = someList.iterator(); stringIterator.hasNext(); ) {
String item = stringIterator.next();
System.out.println(item);
}
如果Expression必须具有数组类型T[]，那么：
String[] someArray = new String[2];
someArray[0] = "Apple";
someArray[1] = "Ball";
for(String item2 : someArray) {
System.out.println(item2);
}
// IS TRANSLATED TO:
for (int i = 0; i < someArray.length; i++) {
String item2 = someArray[i];
System.out.println(item2);
}
Java 8引入了通常表现更好的流。我们可以将它们用作：
someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);
答案 9 :(得分：20)
Java“for-each”循环结构将允许迭代两种类型的对象：
T[] （任何类型的数组） java.lang.Iterable<T> Iterable<T>界面只有一种方法：Iterator<T> iterator()。这适用于Collection<T>类型的对象，因为Collection<T>接口扩展了Iterable<T>。
答案 10 :(得分：15)
维基百科中提到的foreach循环的概念如下所示：
与其他for循环结构不同，通常是foreach循环 保持没有明确的反击：他们基本上说“做到这一点 这一套中的所有内容“，而不是”这样做x次“。这避免了 潜在的逐个错误，使代码更容易阅读。
因此foreach循环的概念描述了循环不使用任何显式计数器，这意味着不需要使用索引遍历列表，因此它可以使用户免于一个一个错误。为了描述这个逐个错误的一般概念，让我们举一个循环的例子来使用索引在列表中遍历。
// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++){
}
但是假设列表以索引1开头，那么这个循环将抛出一个异常，因为它在索引0处没有找到任何元素，这个错误被称为一个一个错误。因此，为了避免这种逐个错误，使用了foreach循环的概念。可能还有其他优点，但我认为这是使用foreach循环的主要概念和优势。
答案 11 :(得分：11)
for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
String item = itr.next();
System.out.println(item);
}
答案 12 :(得分：9)
另请注意，在原始问题中使用“foreach”方法确实存在一些限制，例如在迭代期间无法从列表中删除项目。
新的for循环更容易阅读，不需要单独的迭代器，但只能在只读迭代过程中使用。
答案 13 :(得分：9)
使用包括Java 7在内的Java旧版本，您可以按以下方式使用foreach循环。
List<String> items = new ArrayList<>();
items.add("A");
items.add("B");
items.add("C");
items.add("D");
items.add("E");
for(String item : items){
System.out.println(item);
}
以下是在foreach中使用Java 8循环的最新方法
（使用forEach + lambda表达式或方法引用循环一个列表）
//lambda
//Output : A,B,C,D,E
items.forEach(item->System.out.println(item));
//method reference
//Output : A,B,C,D,E
items.forEach(System.out::println);
有关更多信息，请参见此链接。
答案 14 :(得分：9)
这是一个等效的表达方式。
for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
System.out.println(sit.next());
}
答案 15 :(得分：8)
forEach的替代方案，以避免“为每个人”：
List<String> someList = new ArrayList<String>();
变式1（普通）：
someList.stream().forEach(listItem -> {
System.out.println(listItem);
});
变体2（并行执行（更快））：
someList.parallelStream().forEach(listItem -> {
System.out.println(listItem);
});
答案 16 :(得分：7)
通过删除所有基本的循环混乱，它为您的代码增添了美感。它为您的代码提供了一个干净的外观，以下是合理的。
正常for循环：
void cancelAll(Collection<TimerTask> list) {
for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
i.next().cancel();
}
使用for-each：
void cancelAll(Collection<TimerTask> list) {
for (TimerTask t : list)
t.cancel();
}
for-each 是实现 Iterator 的集合上的构造。请记住，您的收藏应该实施 Iterator ;否则你不能将它与for-each一起使用。
以下行被列为“列表中的每个TimerTask。”
for (TimerTask t : list)
对于for-each，出错的可能性较小。您不必担心初始化迭代器或初始化循环计数器并终止它（可能存在错误的范围）。
答案 17 :(得分：6)
在Java 8之前，您需要使用以下内容：
Iterator<String> iterator = someList.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
然而，随着Java 8中Streams的引入，你可以用更少的语法做同样的事情。例如，您可以执行someList：
someList.stream().forEach(System.out::println);
您可以找到有关溪流here的更多信息。
答案 18 :(得分：6)
在Java 8中，他们引入了forEach。使用列表，可以循环映射。
循环使用每个列表
pyInstaller=3.3.1或
List<String> someList = new ArrayList<String>();
someList.add("A");
someList.add("B");
someList.add("C");
someList.forEach(listItem -> System.out.println(listItem))
为每个地图使用一个地图
someList.forEach(listItem-> {
System.out.println(listItem);
});
或
Map<String, String> mapList = new HashMap<>();
mapList.put("Key1", "Value1");
mapList.put("Key2", "Value2");
mapList.put("Key3", "Value3");
mapList.forEach((key,value)->System.out.println("Key: " + key + " Value : " + value));
答案 19 :(得分：6)
看起来像这样。非常苛刻。
for (Iterator<String> i = someList.iterator(); i.hasNext(); )
System.out.println(i.next());
Sun documentation中每个的都有很好的写作。
答案 20 :(得分：5)
正如许多好的答案所说，如果一个对象想要使用Iterable interface循环，则必须实现for-each。
我将发布一个简单的示例，并尝试以不同的方式解释for-each循环的工作原理。
for-each循环示例：
public class ForEachTest {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("111");
list.add("222");
for (String str : list) {
System.out.println(str);
}
}
}
然后，如果我们使用javap反编译这个类，我们将得到这个字节码样本：
public static void main(java.lang.String[]);
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=4, args_size=1
0: new #16 // class java/util/ArrayList
3: dup
4: invokespecial #18 // Method java/util/ArrayList."<init>":()V
7: astore_1
8: aload_1
9: ldc #19 // String 111
11: invokeinterface #21, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
16: pop
17: aload_1
18: ldc #27 // String 222
20: invokeinterface #21, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
25: pop
26: aload_1
27: invokeinterface #29, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
从样本的最后一行可以看出，编译器会在编译时自动将for-each关键字的使用转换为Iterator的使用。这可以解释为什么没有实现Iterable interface的对象在尝试使用Exception循环时会抛出for-each。
答案 21 :(得分：3)
public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
for(int k=0;k<totalsize;k++)
{
fullst.addAll();
}
}
答案 22 :(得分：3)
正如许多其他答案正确指出的那样，for each loop只是同一个旧for loop上的语法糖，编译器将其翻译到相同的for循环。
javac（打开jdk）具有一个开关-XD-printflat，该开关生成一个Java文件，其中删除了所有语法糖。 完整的命令如下所示< / p>
javac -XD-printflat -d src/ MyFile.java
//-d is used to specify the directory for output java file
要回答这个问题，我创建了一个文件，并写了两个版本的for each，一个版本是array，另一个版本是list。我的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);
}
}
}
当我使用上面的开关compiled使用此文件时，得到以下输出。
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);
}
}
}
}
您可以看到，每个循环的其他语法糖（自动装箱）已更改为简单循环。
答案 23 :(得分：3)
Java for each loop（又名for enhanced for loop）是for循环的简化版本。优点是编写的代码更少，管理的变量更少。缺点是您无法控制步长值，也无法访问循环体内的循环索引。
当步长值为1的简单增量并且只需要访问当前循环元素时，最好使用它们。例如，如果您需要遍历数组或Collection中的每个元素而不在当前元素的前面或后面偷看。
没有循环初始化，没有布尔条件，步长值是隐式的，是一个简单的增量。这就是为什么它们被认为比常规循环简单得多。
增强的for循环遵循以下执行顺序：
1）循环体
2）从步骤1开始重复，直到遍历整个数组或集合
示例 - 整数数组
int [] intArray = {1, 3, 5, 7, 9};
for(int currentValue : intArray) {
System.out.println(currentValue);
}
currentValue变量保存在intArray数组中循环的当前值。请注意，没有明确的步长值 - 它总是增加1。
结肠可以被认为是指“在”中。因此增强的for循环声明表明：循环遍及intArray并将当前数组的值存储在 currentValue变量中。
输出：
1
3
5
7
9
示例 - 字符串数组
我们可以使用for-each循环迭代字符串数组。循环声明声明：遍历myStrings String数组并将当前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值存储在 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字符串集并将当前设置值存储在 currentItem变量中。请注意，由于这是一个Set，因此不会存储重复的String值。
输出：
alpha
delta
beta
gamma
答案 24 :(得分：2)
Java for-each习惯用法只能应用于 * Iterable 类型的数组或对象。这个成语是 隐式 ，因为它真正由Iterator支持。迭代器由程序员编程，通常使用整数索引或节点（取决于数据结构）来跟踪其位置。在纸面上它比常规for循环慢，对于像“数组”和“列表”这样的“线性”结构来说最少，但它提供了更大的抽象。
答案 25 :(得分：1)
这看起来很疯狂，但嘿工作
List<String> someList = new ArrayList<>(); //has content
someList.forEach(System.out::println);
这很有效。的 魔术
答案 26 :(得分：0)
我认为这会奏效：
for (Iterator<String> i = someList.iterator(); i.hasNext(); ) {
String x = i.next();
System.out.println(x);
}
答案 27 :(得分：0)
代码将是：
import java.util.ArrayList;
import java.util.List;
public class ForLoopDemo {
public static void main(String[] args) {
List<String> someList = new ArrayList<String>();
someList.add("monkey");
someList.add("donkey");
someList.add("skeleton key");
//Iteration using For Each loop
System.out.println("Iteration using For Each loop:");
for (String item : someList) {
System.out.println(item);
}
//Iteration using normal For loop
System.out.println("\nIteration using normal For loop:");
for (int index = 0; index < someList.size(); index++) {
System.out.println(someList.get(index));
}
}
}
答案 28 :(得分：-1)
List<Item> Items = obj.getItems();
for(Item item:Items)
{
System.out.println(item);
}
迭代Items表中的所有对象。