关于FACHACH：Java”for each'”如何工作？

How does the Java 'for each' loop work?

考虑：

1 2	List<String> someList = new ArrayList<String>(); // add"monkey","donkey","skeleton key" to someList

1
2
3

for (String item : someList) {
System.out.println(item);
}

是什么样子的for等效回路将不使用的每个语法吗？

1
2
3
4

for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
String item = i.next();
System.out.println(item);
}

请注意，如果您需要在循环中使用i.remove();，或者以某种方式访问实际迭代器，则不能使用for ( : )习惯用法，因为实际迭代器只是推断出来的。

正如DenisBueno所指出的，此代码适用于实现Iterable接口的任何对象。

此外，如果for (:)习惯用法的右侧是array而不是Iterable对象，则内部代码使用int索引计数器，并检查array.length。请参见Java语言规范。

每个的构造对于数组也是有效的。例如

1
2
3
4
5

String[] fruits = new String[] {"Orange","Apple","Pear","Strawberry" };

for (String fruit : fruits) {
// fruit is an element of the `fruits` array.
}

基本上相当于

1
2
3
4

for (int i = 0; i < fruits.length; i++) {
String fruit = fruits[i];
// fruit is an element of the `fruits` array.
}

所以，总体总结：
[nsayer]以下是正在发生的事情的较长形式：

1
2
3
4
for(Iterator<String> i = someList.iterator(); i.hasNext(); ) {
String item = i.next();
System.out.println(item);
}

Note that if you need to use
i.remove(); in your loop, or access
the actual iterator in some way, you
cannot use the for( : ) idiom, since
the actual Iterator is merely
inferred.

[丹尼斯·布诺]

It's implied by nsayer's answer, but
it's worth noting that the OP's for(..)
syntax will work when"someList" is
anything that implements
java.lang.Iterable -- it doesn't have
to be a list, or some collection from
java.util. Even your own types,
therefore, can be used with this
syntax.

在Java 5中添加的EDCOX1的0个循环(也称为"增强for循环")相当于使用EDCOX1×1个词——它是用于同一事物的语法糖。因此，在逐个按顺序读取每个元素时，应始终在迭代器上选择foreach，因为它更方便和简洁。

前额

1
2
3

for(int i : intList) {
System.out.println("An element in the list:" + i);
}

迭代器

1
2
3
4

Iterator<Integer> intItr = intList.iterator();
while(intItr.hasNext()) {
System.out.println("An element in the list:" + intItr.next());
}

在某些情况下，您必须直接使用Iterator。例如，在使用foreachcan(will？)时尝试删除元素。产生一个ConcurrentModificationException。

foreach与for的比较：基本差异

for和foreach之间唯一实际的区别是，在可索引对象的情况下，您没有访问索引的权限。需要基本for循环时的示例：

1
2
3
4
5
6
7

for(int i = 0; i < array.length; i++) {
if(i < 5) {
// Do something special
} else {
// Do other stuff
}
}

虽然可以使用foreach手动创建单独的index int变量，

1
2
3
4
5

int idx = -1;
for(int i : intArray) {
idx++;
...
}

不建议这样做，因为变量范围不理想，基本的for循环只是这个用例的标准和预期格式。

foreach与for的比较：性能

访问集合时，foreach比基本for循环的数组访问快得多。然而，在访问数组时(至少是使用基元数组和包装数组)，通过索引进行访问的速度要快得多。

为基元int数组的迭代器和索引访问之间的差异计时

访问int或Integer数组时，索引比迭代器快23-40%。下面是本文底部测试类的输出，它对100元素基元int数组(a是迭代器，b是索引)中的数字求和：

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

[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%。

对于集合，迭代器比索引快

然而，对于Integers的List而言，迭代器显然是赢家。只需将测试类中的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、length改为size()等)进行必要的修改：

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

[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)

在一个测试中，它们几乎是等价的，但在集合中，迭代器获胜。

*这篇文章基于我在堆栈溢出上写的两个答案：

Java中每个循环的用法和语法
我应该使用迭代器还是使用forloop来迭代？

更多信息：哪个更有效，一个for each循环，还是一个迭代器？

完整的测试类

我创建了这个比较在堆栈溢出上读取这个问题后执行任何两件事所需的时间的类：

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

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迭代器知识的答案。它不那么精确，但对教育有用。

在编程时，我们经常编写如下代码：

1
2
3
4

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语法允许以更自然、更少语法干扰的方式编写这种常见模式。

1
2
3

for(char grade : grades) { // foreach grade in grades
System.out.print(grade); // print that grade
}

此外，此语法对于不支持数组索引但可以实现Java可迭代接口的对象(如列表或集合)是有效的。

Java中的每个循环使用基础迭代器机制。因此，它与以下内容相同：

1
2
3
4
5
6

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}

在Java 8特性中，您可以使用：

1
2
3
4
5

List<String> messages = Arrays.asList("First","Second","Third");

void forTest(){
messages.forEach(System.out::println);
}

产量

1
2
3

First
Second
Third

NSayer的答案暗示了这一点，但值得注意的是，当"someList"是实现java.lang.iterable的任何东西时，…)语法将起作用——它不必是一个列表，也不必是java.util的一些集合。因此，即使您自己的类型也可以与此语法一起使用。

foreach循环语法是：

1	for (type obj:array) {...}

例子：

1
2
3
4

String[] s = {"Java","Coffe","Is","Cool"};
for (String str:s /*s is the array*/) {
System.out.println(str);
}

输出：

1
2
3
4

Java
Coffe
Is
Cool

警告：可以使用foreach循环访问数组元素，但不能初始化它们。使用原始的for循环。

警告：必须将数组类型与其他对象匹配。

1	for (double b:s) // Invalid-double is not String

如果要编辑元素，请使用原始的for循环，如下所示：

1
2
3
4
5
6

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转储到控制台，我们得到：

1
2
3
4

hello
2 is cool
hello
hello

Java"为每个"循环构造将允许对两种类型的对象进行迭代：

T[](任何类型的数组)
java.lang.Iterable

Iterable接口只有一种方法：Iterator iterator()。这适用于Collection类型的对象，因为Collection接口扩展了Iterable。

如JLS中所定义，每个回路可以有两种形式：

如果表达式类型是Iterable的子类型，那么翻译如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

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);
}

如果表达式必须具有数组类型T[]，则：

1
2
3
4
5
6
7
8
9
10
11
12
13

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引入了通常执行得更好的流。我们可以将其用作：

1 2	someList.stream().forEach(System.out::println); Arrays.stream(someArray).forEach(System.out::println);

维基百科中提到的foreach循环的概念强调如下：

Unlike other for loop constructs, however, foreach loops usually
maintain no explicit counter: they essentially say"do this to
everything in this set", rather than"do this x times". This avoids
potential off-by-one errors and makes code simpler to read.

因此foreach循环的概念描述了循环不使用任何显式计数器，这意味着不需要使用索引在列表中遍历，因此它可以避免用户因一个错误而关闭。为了用一个错误描述这个关闭的一般概念，让我们以一个循环为例，使用索引遍历一个列表。

1
2
3
4

// 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循环的主要概念和优点。

1
2
3
4

for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
String item = itr.next();
System.out.println(item);
}

还要注意，在原始问题中使用"foreach"方法确实有一些限制，例如在迭代期间无法从列表中删除项。

新的for循环更容易读取，并且不需要单独的迭代器，但只在只读迭代过程中才真正可用。

这是一个等价表达式。

1
2
3

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

使用较旧的Java版本(包括EDCOX1，0)，您可以使用EDCOX1，1，循环，如下所示。

1
2
3
4
5
6
7
8
9
10

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);
}

下面是在Java 8中使用foreach循环的最新方法

(使用foreach和lambda表达式或方法引用循环列表)

1
2
3
4
5
6
7
8

//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);

有关详细信息，请参阅此链接。

https://www.mkyong.com/java8/java-8-foreach-示例/

为了避免你的"为每一个人"而选择for each：

1	List<String> someList = new ArrayList<String>();

变体1(普通)：

1
2
3

someList.stream().forEach(listItem -> {
System.out.println(listItem);
});

变体2(并行执行(更快))：

1
2
3

someList.parallelStream().forEach(listItem -> {
System.out.println(listItem);
});

它消除了所有基本的循环混乱，为代码增添了美感。它使您的代码看起来很干净，如下所示。

正常for回路：

1
2
3
4

void cancelAll(Collection<TimerTask> list) {
for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
i.next().cancel();
}

使用：

1
2
3
4

void cancelAll(Collection<TimerTask> list) {
for (TimerTask t : list)
t.cancel();
}

因为每个都是实现迭代器的集合上的构造。请记住，您的集合应该实现迭代器；否则不能将它与for each一起使用。

下一行读作"对于列表中的每个时间任务t"。

1	for (TimerTask t : list)

每种情况下出错的可能性都较小。您不必担心初始化迭代器或初始化循环计数器并终止它(在存在错误范围的地方)。

在Java 8之前，您需要使用以下内容：

1
2
3
4
5
6

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}

然而，随着Java 8中的流的引入，可以用更少的语法来完成同样的事情。例如，对于您的someList，您可以执行以下操作：

1	someList.stream().forEach(System.out::println);

你可以在这里找到更多关于溪流的信息。

看起来像这样。非常粗俗。

1 2	for (Iterator<String> i = someList.iterator(); i.hasNext(); ) System.out.println(i.next());

Sun文档中的每个文档都有一个很好的记录。

在Java 8中，他们引入了FACACH。使用IT列表，可以循环映射。

循环使用的列表

1
2
3
4
5
6

List<String> someList = new ArrayList<String>();
someList.add("A");
someList.add("B");
someList.add("C");

someList.forEach(listItem -> System.out.println(listItem))

或

1
2
3

someList.forEach(listItem-> {
System.out.println(listItem);
});

循环使用每个

1
2
3
4
5
6

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));

或

1
2
3

mapList.forEach((key,value)->{
System.out.println("Key :" + key +" Value :" + value);
});

正如许多好的答案所说，如果一个对象想要使用一个for-each循环，那么它必须实现Iterable interface。

我将发布一个简单的示例，并尝试以不同的方式解释for-each循环的工作原理。

for-each循环示例：

1
2
3
4
5
6
7
8
9
10
11
12
13

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来反编译这个类，我们将得到这个字节码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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的对象在试图使用for-each循环时会抛出Exception。

1
2
3
4
5
6
7

public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
for(int k=0;k<totalsize;k++)
{
fullst.addAll();
}
}

每个循环的Java(Akfor for Roop)是for循环的简化版本。其优点是编写的代码更少，管理的变量更少。缺点是您无法控制步骤值，并且无法访问循环体中的循环索引。

当步骤值是1的简单增量并且您只需要访问当前循环元素时，最好使用它们。例如，如果需要循环遍历数组或集合中的每个元素，而不需要向前或向后查看当前元素。

没有循环初始化，没有布尔条件，步骤值是隐式的，是一个简单的增量。这就是为什么它们被认为比常规的for循环简单得多的原因。

增强的for循环遵循以下执行顺序：

1)环体

2)从步骤1重复，直到遍历整个数组或集合。

示例-整数数组

1
2
3
4

int [] intArray = {1, 3, 5, 7, 9};
for(int currentValue : intArray) {
System.out.println(currentValue);
}

currentValue变量保存在intarray数组中循环的当前值。注意，没有明确的步骤值——它总是以1为增量。

结肠可以被认为是"in"的意思。因此，增强的for循环声明声明声明为：在int array上循环，并将当前数组int值存储在current value变量中。

输出：

1
2
3
4
5

1
3
5
7
9

示例-字符串数组

我们可以使用for-each循环迭代字符串数组。循环声明声明为：循环MyStrings字符串数组，并将当前字符串值存储在currentString变量中。

1
2
3
4
5
6
7
8
9
10

String [] myStrings = {
"alpha",
"beta",
"gamma",
"delta"
};

for(String currentString : myStrings) {
System.out.println(currentString);
}

输出：

1
2
3
4

alpha
beta
gamma
delta

示例-列表

还可以使用增强的for循环对java.util.list进行迭代，如下所示：

1
2
3
4
5
6
7
8
9

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列表，并将当前列表值存储在currentem变量中。

输出：

1
2
3
4

alpha
beta
gamma
delta

范例集

还可以使用增强的for循环在java.util.set上迭代，如下所示：

1
2
3
4
5
6
7
8
9
10
11

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变量中。注意，由于这是一个集合，所以不会存储重复的字符串值。

输出：

1
2
3
4

alpha
delta
beta
gamma

源代码：Java中的循环——终极指南

每个习语的Java只能应用于类型**类型的对象。这个习语是隐式的，因为它真正由迭代器支持。迭代器由程序员编程，通常使用整数索引或节点(取决于数据结构)来跟踪其位置。理论上，它比常规的for循环要慢，至少对于数组和列表这样的"线性"结构来说是这样，但它提供了更大的抽象性。

这看起来很疯狂，但嘿，它起作用了