Javafor each循环是如何工作的？

小开

最佳答案

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

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

正如Denis Bueno所指出的，此代码适用于任何实现#0接口的对象。

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

小开

Java中的for-each循环使用底层迭代器机制。

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

小开

这是一个等价的表达式。

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

小开

它看起来像这样。非常粗糙。

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

在太阳留档中有一个关于为每个的好文章。

小开

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

小开

这是由nsayer的回答暗示的，但值得注意的是，OP的for（…）语法将在实现java.lang.Iterable的任何时工作——它不一定是一个列表，或者java.util.的一些集合。

小开

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

新的for循环更易于阅读，并消除了对单独迭代器的需求，但仅在只读迭代传递中真正可用。

小开

构造为每个也适用于数组。

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（：）习语，因为实际的迭代器仅仅是推测。

[Denis Bueno]

nsayer的回答暗示了这一点，但是值得注意的是，OP的（…）语法将工作时，“某些列表”是任何实现java.lang.可迭代的——它没有是一个列表，或一些收集从java.util.甚至你自己的类型，因此，可以与此一起使用语法。

小开

Java的“for-each”循环构造将允许迭代两种类型的对象：

T[]（任何类型的数组）
java.lang.Iterable<T>

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

小开

这里有一个答案，它不假设Java迭代器的知识。它不太精确，但它对教育很有用。

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

char[] grades = ....for(int i = 0; i < grades.length; i++) {   // for i goes from 0 to grades.lengthSystem.out.print(grades[i]);           // Print grades[i]}

Foreach语法允许以更自然和更少语法噪声的方式编写这种常见模式。

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

此外，此语法对于不支持数组索引但实现JavaIterable接口的列表或集合等对象有效。

小开

维基百科中提到的Foreach循环的概念如下所示：

然而，与其他for循环结构不同，Foreach循环通常维护没有明确的计数器：他们基本上说“这样做是为了这个集合中的所有内容”，而不是“做这个x次”。这避免了离一误差使代码更易于阅读。

因此，Foreach循环的概念描述了循环不使用任何显式计数器，这意味着不需要使用索引来遍历列表，因此它使用户免于一个错误。为了描述这种一个错误的一般概念，让我们举一个使用索引在列表中遍历的循环的例子。

// In this loop it is assumed that the list starts with index 0for(int i=0; i<list.length; i++){
}

但是假设列表以索引1开头，那么这个循环将抛出一个异常，因为它在索引0处找不到元素，这个错误被称为off-by-one错误。因此为了避免这种off-by-one错误，使用Foreach循环的概念。可能还有其他优点，但这是我认为使用Foreach循环的主要概念和优势。

小开

Foreach循环语法是：

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

示例：

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

输出：

JavaCoffeIsCool

警告：您可以使用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 indexs[i]="2 is cool";elses[i] = "hello";}

现在，如果我们将s转储到控制台，我们会得到：

hello2 is coolhellohello

小开

在Java5中添加的for-each循环（也称为“增强的for循环”）相当于使用#0--它是同一事物的语法糖。因此，在逐个按顺序读取每个元素时，应始终选择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());}

在某些情况下，您必须直接使用Iterator。例如，在使用for-each时尝试删除元素会（将？）导致ConcurrentModificationException。

for-each与for-loop：基本差异

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

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

尽管您可以使用for-each手动创建一个单独的索引int变量，

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

…不建议这样做，因为可变作用域并不理想，基本的for循环只是这个用例的标准和预期格式。

for-each vs. for-loop：性能

访问集合时，for-each比基本for循环的数组访问显着更快。然而，在访问数组时——至少使用原始数组和包装数组——通过索引访问的速度要快得多。

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

当访问int或Integer数组时，索引比迭代器快23-40%。这是本文底部测试类的输出，它对100元素原始整型数组中的数字进行了求和（A是迭代器，B是索引）：

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 358,597,622 nanosecondsTest B: 269,167,681 nanosecondsB faster by 89,429,941 nanoseconds (24.438799231635727% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 377,461,823 nanosecondsTest B: 278,694,271 nanosecondsB faster by 98,767,552 nanoseconds (25.666236154695838% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 288,953,495 nanosecondsTest B: 207,050,523 nanosecondsB faster by 81,902,972 nanoseconds (27.844689860906513% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 375,373,765 nanosecondsTest B: 283,813,875 nanosecondsB faster by 91,559,890 nanoseconds (23.891659337194227% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 375,790,818 nanosecondsTest B: 220,770,915 nanosecondsB faster by 155,019,903 nanoseconds (40.75164734599769% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 326,373,762 nanosecondsTest B: 202,555,566 nanosecondsB faster by 123,818,196 nanoseconds (37.437545972215744% faster)

我还为Integer数组运行了这个，索引仍然是明显的赢家，但只快了18%到25%。

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

然而，对于Integers中的List，迭代器显然是赢家。只需将test-class中的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 1000000Test A: 3,429,929,976 nanosecondsTest B: 5,262,782,488 nanosecondsA faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000Test A: 2,907,391,427 nanosecondsTest B: 3,957,718,459 nanosecondsA faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000Test A: 2,566,004,688 nanosecondsTest B: 4,221,746,521 nanosecondsA faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000Test A: 2,770,945,276 nanosecondsTest B: 3,829,077,158 nanosecondsA faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000Test A: 3,467,474,055 nanosecondsTest B: 5,183,149,104 nanosecondsA faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000Test A: 3,439,983,933 nanosecondsTest B: 3,509,530,312 nanosecondsA faster by 69,546,379 nanoseconds (1.4816434912159906% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000Test A: 3,451,101,466 nanosecondsTest B: 5,057,979,210 nanosecondsA faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)

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

*这篇文章基于我在Stack Overflow上写的两个答案：

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

完整的测试类

在阅读了Stack Overflow上的这个问题之后，我创建了这个比较时间-它-需要-做-任何两件事的类：

import  java.text.NumberFormat;import  java.util.Locale;
/**&lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;
@see  &lt;CODE&gt;&lt;A HREF=&quot;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt;**/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 parametertry {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...STARTint[] 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...STARTpublic 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
}

小开

在Java8个特性中，您可以使用：

List<String> messages = Arrays.asList("First", "Second", "Third");
void forTest(){messages.forEach(System.out::println);}

产出

FirstSecondThird

小开

for-each习惯用法Java只能应用于类型*可迭代的数组或对象。这个习惯用法是隐式，因为它真正由Iterator支持。Iterator由程序员编程，通常使用整数索引或节点（取决于数据结构）来跟踪其位置。在纸面上，它比常规的for循环慢，至少对于数组和列表等“线性”结构来说是这样，但它提供了更大的抽象。

小开

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

正常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一起使用。

下面一行读为“对于列表中的每个TimerTranstt。”

for (TimerTask t : list)

在for-each的情况下出错的可能性更小。你不必担心初始化迭代器或初始化循环计数器并终止它（在有错误空间的情况下）。

小开

如JLS中定义的，每个人循环可以有两种形式：

如果表达式的类型是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);}

如果表达式必须具有数组类型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);}

Java8引入了流，它们在大小合适的数据集上通常表现更好。我们可以将它们用作：

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

小开

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

小开

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

我将发布一个简单的示例，并尝试以不同的方式解释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_STATICCode:stack=2, locals=4, args_size=10: new           #16                 // class java/util/ArrayList3: dup4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V7: astore_18: aload_19: ldc           #19                 // String 11111: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z16: pop17: aload_118: ldc           #27                 // String 22220: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z25: pop26: aload_127: invokeinterface #29,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;

从示例的最后一行可以看出，编译器会在编译时自动将for-each关键字的使用转换为Iterator的使用。这可能解释了为什么没有实现Iterable interface的对象在尝试使用for-each循环时会抛出Exception。

小开

为了避免你的“for each”，for每个的替代方案：

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

备选案文1（普通）：

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

变式2（并行执行（更快））：

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

小开

这看起来很疯狂，但它奏效了

List<String> someList = new ArrayList<>(); //has contentsomeList.forEach(System.out::println);

这个工作魔法

小开

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

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

但是，随着Java8中Streams的引入，你可以用更少的语法做同样的事情。

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

您可以找到有关流这里的更多信息。

小开

每个循环的Java（又名增强的for循环）是for循环的简化版本。优点是需要编写的代码更少，需要管理的变量更少。缺点是您无法控制步长值，也无法访问循环主体中的循环索引。

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

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

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

1）回路主体

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

示例-整数数组

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

当前值变量保存在intArray数组中循环的当前值。请注意，没有明确的步长值——它总是递增1。

冒号可以被认为是“in”的意思。因此，增强的for循环声明指出：循环intArray并将当前数组int值在存储为当前值变量。

输出：

示例-字符串数组

我们可以使用for-each循环遍历字符串数组。循环声明状态为：循环遍历myStrings String数组并将当前String值在存储为当前字符串变量。

String [] myStrings  = {"alpha","beta","gamma","delta"};
for(String currentString : myStrings) {System.out.println(currentString);}

输出：

alphabetagammadelta

示例-列表

增强的for循环也可用于迭代java.util.列表，如下所示：

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字符串列表并将当前列表值在存储在当前项目变量中。

输出：

alphabetagammadelta

示例-设置

增强的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 of Strings并将当前Set值在存储在当前tItem变量中。请注意，由于这是一个Set，因此不会存储重复的String值。

输出：

alphadeltabetagamma

来源：Java中的循环-终极指南

小开

使用旧的Java版本，包括Java7，您可以使用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);}

以下是在Java8中使用为每个循环的最新方法（使用forEach+lambda表达式或方法引用循环列表）。

lambda

// Output: A,B,C,D,Eitems.forEach(item->System.out.println(item));

方法参考

// Output: A,B,C,D,Eitems.forEach(System.out::println);

有关更多信息，请参阅"Java8对于每个例子。

小开

在Java8中，他们引入了for每个。使用它列表，地图可以循环。

循环使用每个列表

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

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

或

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

小开

正如许多其他答案正确指出的那样，为每个循环只是相同的旧进行循环上的语法糖，编译器将其转换为相同的旧进行循环。

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

当我用上面的开关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);}}}}

您可以看到，与其他语法糖（自动装箱）一起，为每个循环更改为简单循环。

小开

我认为这将工作：

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

小开

代码将是：

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 loopSystem.out.println("Iteration using a For Each loop:");for (String item : someList) {System.out.println(item);}
// Iteration using a normal For loopSystem.out.println("\nIteration using normal For loop: ");for (int index = 0; index < someList.size(); index++) {System.out.println(someList.get(index));}}}

小开

使用for每个：

int[] numbers = {1,2,3,4,5};
Arrays.stream(numbers).forEach(System.out::println);

回应：

12345
The process finished with exit code 0

PS：您需要一个数组（int[] numbers）和import java.util.Arrays;