哪个更有效，一个for-each循环或一个迭代器？

遍历集合的最有效方法是哪种？

List<Integer>  a = new ArrayList<Integer>();
for (Integer integer : a) {
  integer.toString();
}

要么

List<Integer>  a = new ArrayList<Integer>();
for (Iterator iterator = a.iterator(); iterator.hasNext();) {
   Integer integer = (Integer) iterator.next();
   integer.toString();
}

请注意，尽管最后一个问题的答案之一接近，但这不是this，this，this或this的精确重复。之所以不是这样，是因为其中大多数是比较循环get(i)，而不是使用迭代器，而您在循环中调用该循环。

正如元建议，我将发布我对这个问题的答案。

如果您只是在集合上徘徊以读取所有值，那么使用迭代器或新的for循环语法之间就没有区别，因为新语法仅在水下使用迭代器。

但是，如果您是指循环旧的“ c-style”循环：

for(int i=0; i<list.size(); i++) {
   Object o = list.get(i);
}

然后，取决于基础数据结构，新的for循环或迭代器可能会效率更高。这样做的原因是，对于某些数据结构，get(i)是O（n）运算，这使循环成为O（n ²）运算。传统的链表就是这种数据结构的一个例子。作为基本要求，所有迭代器next()都应为O（1）操作，从而使循环为O（n）。

要验证新的for循环语法是否在水下使用迭代器，请比较以下两个Java代码段生成的字节码。首先是for循环：

List<Integer>  a = new ArrayList<Integer>();
for (Integer integer : a)
{
  integer.toString();
}
// Byte code
 ALOAD 1
 INVOKEINTERFACE java/util/List.iterator()Ljava/util/Iterator;
 ASTORE 3
 GOTO L2
L3
 ALOAD 3
 INVOKEINTERFACE java/util/Iterator.next()Ljava/lang/Object;
 CHECKCAST java/lang/Integer
 ASTORE 2 
 ALOAD 2
 INVOKEVIRTUAL java/lang/Integer.toString()Ljava/lang/String;
 POP
L2
 ALOAD 3
 INVOKEINTERFACE java/util/Iterator.hasNext()Z
 IFNE L3

其次，迭代器：

List<Integer>  a = new ArrayList<Integer>();
for (Iterator iterator = a.iterator(); iterator.hasNext();)
{
  Integer integer = (Integer) iterator.next();
  integer.toString();
}
// Bytecode:
 ALOAD 1
 INVOKEINTERFACE java/util/List.iterator()Ljava/util/Iterator;
 ASTORE 2
 GOTO L7
L8
 ALOAD 2
 INVOKEINTERFACE java/util/Iterator.next()Ljava/lang/Object;
 CHECKCAST java/lang/Integer
 ASTORE 3
 ALOAD 3
 INVOKEVIRTUAL java/lang/Integer.toString()Ljava/lang/String;
 POP
L7
 ALOAD 2
 INVOKEINTERFACE java/util/Iterator.hasNext()Z
 IFNE L8

如您所见，生成的字节码实际上是相同的，因此使用任何一种形式都不会降低性能。因此，对于大多数人来说，应该选择for循环，因为它具有较少的样板代码，因此您应该选择最美观的循环形式。

差异不在于性能，而在于功能。直接使用引用时，可以显式地使用某种迭代器（例如List.iterator（）与List.listIterator（），尽管在大多数情况下它们返回相同的实现）。您还可以在循环中引用Iterator。这使您可以执行类似的操作，例如从集合中删除项目而不会出现ConcurrentModificationException。

例如

还行吧：

Set<Object> set = new HashSet<Object>();
// add some items to the set

Iterator<Object> setIterator = set.iterator();
while(setIterator.hasNext()){
     Object o = setIterator.next();
     if(o meets some condition){
          setIterator.remove();
     }
}

这不是，因为它将引发并发修改异常：

Set<Object> set = new HashSet<Object>();
// add some items to the set

for(Object o : set){
     if(o meets some condition){
          set.remove(o);
     }
}

为了扩展Paul自己的答案，他证明了特定编译器（大概是Sun的javac？）上的字节码是相同的，但是不能保证不同的编译器会生成相同的字节码，对吗？要了解两者之间的实际区别，让我们直接看一下源代码并检查Java语言规范，特别是14.14.2，“ for语句的增强”：

增强的for语句等效于for以下形式的基本语句：

for (I #i = Expression.iterator(); #i.hasNext(); ) {
    VariableModifiers(opt) Type Identifier = #i.next();    
    Statement 
}

换句话说，JLS要求两者相等。从理论上讲，这可能意味着字节码中的边际差异，但实际上，需要增强的for循环来：

• 调用.iterator()方法
• 用 .hasNext()
• 通过以下方式使局部变量可用 .next()

因此，换句话说，出于所有实际目的，字节码将是相同或几乎相同的。很难设想任何编译器实现都会导致两者之间的重大差异。

该foreach发动机罩被创建iterator，调用hasNext（）和调用next（）来获取价值; 仅当您使用实现RandomomAccess的东西时，才会出现性能问题。

for (Iterator<CustomObj> iter = customList.iterator(); iter.hasNext()){
   CustomObj custObj = iter.next();
   ....
}

基于迭代器的循环的性能问题是因为：

1. 分配一个对象，即使列表为空（Iterator<CustomObj> iter = customList.iterator();）;
2. iter.hasNext() 在循环的每次迭代期间，都有一个invokeInterface虚拟调用（遍历所有类，然后在跳转之前进行方法表查找）。
3. 迭代器的实现必须至少进行2个字段查找才能使hasNext()调用值成为值：＃1获取当前计数，＃2获取总计数
4. 在主体循环中，还有另一个invokeInterface虚拟调用iter.next（因此：在跳转之前遍历所有类并进行方法表查找），还必须进行字段查找：＃1获取索引，＃2获取对引用的引用数组来执行偏移量（在每次迭代中）。

可能的优化方法是index iteration使用缓存的大小查找切换到：

for(int x = 0, size = customList.size(); x < size; x++){
  CustomObj custObj = customList.get(x);
  ...
}

这里我们有：

1. customList.size()在for循环的初始创建中调用一个invokeInterface虚拟方法以获取大小
2. customList.get(x)在body循环期间进行get方法调用，这是对数组的字段查找，然后可以对数组进行偏移

我们减少了大量的方法调用和字段查找。这是您不希望使用的对象LinkedList或不是RandomAccess集合obj的对象，否则，customList.get(x)它将变成LinkedList每次迭代都必须遍历的对象。

当您知道这是任何RandomAccess基于列表的集合时，这是完美的。

foreach无论如何在后台使用迭代器。它实际上只是语法糖。

考虑以下程序：

import java.util.List;
import java.util.ArrayList;

public class Whatever {
    private final List<Integer> list = new ArrayList<>();
    public void main() {
        for(Integer i : list) {
        }
    }
}

让我们编译它javac Whatever.java，
而读取的字节码拆卸main()，使用javap -c Whatever：

public void main();
  Code:
     0: aload_0
     1: getfield      #4                  // Field list:Ljava/util/List;
     4: invokeinterface #5,  1            // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
     9: astore_1
    10: aload_1
    11: invokeinterface #6,  1            // InterfaceMethod java/util/Iterator.hasNext:()Z
    16: ifeq          32
    19: aload_1
    20: invokeinterface #7,  1            // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
    25: checkcast     #8                  // class java/lang/Integer
    28: astore_2
    29: goto          10
    32: return

我们可以看到它可以foreach编译成以下程序：

• 使用创建迭代器 List.iterator()
• 如果Iterator.hasNext()：调用Iterator.next()并继续循环

至于“为什么这个无用的循环为什么没有从编译后的代码中得到优化呢？我们可以看到它对列表项没有任何作用”：嗯，您有可能对可迭代的代码进行编码，从而.iterator()产生副作用，否则.hasNext()会有副作用或有意义的后果。

您很容易想到，一个表示数据库中可滚动查询的可迭代对象可能会产生重大变化.hasNext()（例如，与数据库联系，或者因为到达结果集的末尾而关闭游标）。

因此，即使我们可以证明循环主体中什么也没有发生……要证明迭代时什么也没有有意义/结果没有发生，这是更昂贵的（难处理的吗？）。编译器必须将此空循环体留在程序中。

我们所希望的最好的结果是编译器警告。有趣的是javac -Xlint:all Whatever.java，没有警告我们有关此空循环的主体。IntelliJ IDEA可以。诚然，我已经将IntelliJ配置为使用Eclipse Compiler，但这可能不是原因。

迭代器是Java Collections框架中的一个接口，它提供遍历或迭代集合的方法。

当您的动机只是遍历集合以读取其元素时，迭代器和for循环的行为相似。

for-each 只是迭代Collection的一种方法。

例如：

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

//using for-each loop
for(String msg: messages){
    System.out.println(msg);
}

//using iterator 
Iterator<String> it = messages.iterator();
while(it.hasNext()){
    String msg = it.next();
    System.out.println(msg);
}

并且for-each循环只能在实现迭代器接口的对象上使用。

现在回到for循环和迭代器的情况。

当您尝试修改集合时会有所不同。在这种情况下，迭代器由于其fail-fast属性而更加高效。即。它在遍历下一个元素之前检查基础集合的结构是否有任何修改。如果找到任何修改，它将抛出ConcurrentModificationException。

（注意：迭代器的此功能仅适用于java.util包中的集合类。不适用于并发集合，因为它们本质上是故障安全的）

在使用集合时，我们应避免使用传统的for循环。我给出的简单原因是for循环的复杂度约为O（sqr（n）），而Iterator甚至增强的for循环的复杂度仅为O（n）。因此，它会产生性能差异。.只需列出约1000个项目的清单，然后使用两种方法进行打印即可。并打印执行时差。您会看到差异。