使用迭代器有什么优势？

Question

for(Element e : elementList) 

for (Iterator<Element> itr = elementList.iterator(); itr.hasNext();) 

第一个简单得多。我想做第二个有什么优点或原因吗？

Answer 1

它们在内部都使用迭代器，唯一的区别是当您使用增强for循环时代码更清晰和更短。以下是javadoc对两者所说的内容：

迭代集合比它需要的更丑。考虑以下方法，它需要定时器任务的集合并取消它们：

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

迭代器只是混乱。此外，这是一个错误的机会。迭代器变量在每个循环中出现三次：这是两次错误的机会。 for-each构造摆脱了混乱和错误的机会。下面是该示例的外观与for-each结构：“在”“在C每个TimerTask的T”

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

当你看到冒号（:)它读成环路上面写明作为你可以看到，for-each构造与泛型完美地结合在一起。它保留了所有类型的安全性，同时消除了剩余的杂波。因为您不必声明迭代器，所以不必为其提供通用声明。 （编译器为您完成此你背后，但你不必用它关心自己）

有关为什么我们要使用for-each循环，而不是迭代器完整的描述，请阅读本：

http://docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html

Answer 2

第一种形式是在Java 5中引入的，第二种形式主要是在早期版本的语言的旧代码中找到的。尽管如此，仍然有几种情况你仍然需要使用第二种形式;例如，如果循环需要在迭代时删除一些（或全部）元素，那么您需要具有itr，因此您可以调用它的remove方法。

Answer 3

Iterator可以remove()从集合，它可以不使用每个循环

Answer 4

没有性能上的差异来完成的元素。但通过使用迭代器，您将可以使用更多的功能。例如，你可以在循环中引用迭代器。这允许您执行诸如删除收集项目的操作，获得ConcurrentModificationException。

您可以使用下面

for (Iterator<Element> itr = elementList.iterator(); itr.hasNext();){ 
    if(o meets some condition){ 
      itr.remove(); 
    } 
} 

但不是这个

for(Element e : elementList){ 
     if(o meets some condition){ 
       elementList.remove(e); 
     } 
    } 

但是，如果这种差异不打扰你，那么你可以使用你的安慰之一。

similar so question

Answer 5

它们非常相似。考虑以下代码

import java.util.Iterator; 
import java.util.ArrayList; 

public class IteratorTest { 

    public static void main(String[] args){ 

    ArrayList<Object> list = new ArrayList(); 
    list.add(new Object()); 
    list.add(new Object()); 

    for(Object o : list) 
     System.out.println(o); 

    for(Iterator<Object> itr = list.iterator();itr.hasNext();) 
     System.out.println(itr.next()); 


    } 
} 

然后，我们编译它，并使用

javap -c IteratorTest 

拆解和得到以下字节码的主要方法

public static void main(java.lang.String[]); 
    Code: 
     0: new   #2     // class java/util/ArrayList 
     3: dup   
     4: invokespecial #3     // Method java/util/ArrayList."<init>":()V 
     7: astore_1  
     8: aload_1  
     9: new   #4     // class java/lang/Object 
     12: dup   
     13: invokespecial #1     // Method java/lang/Object."<init>":()V 
     16: invokevirtual #5     // Method java/util/ArrayList.add:(Ljava/lang/Object;)Z 
     19: pop   
     20: aload_1 
     21: new   #4     // class java/lang/Object 
     24: dup   
     25: invokespecial #1     // Method java/lang/Object."<init>":()V 
     28: invokevirtual #5     // Method java/util/ArrayList.add:(Ljava/lang/Object;)Z 
     31: pop   
     32: aload_1  
     33: invokevirtual #6     // Method java/util/ArrayList.iterator:()Ljava/util/Iterator; 
     36: astore_2  
     37: aload_2  
     38: invokeinterface #7, 1   // InterfaceMethod java/util/Iterator.hasNext:()Z 
     43: ifeq   63 
     46: aload_2  
     47: invokeinterface #8, 1   // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object; 
     52: astore_3  
     53: getstatic  #9     // Field java/lang/System.out:Ljava/io/PrintStream; 
     56: aload_3  
     57: invokevirtual #10     // Method java/io/PrintStream.println:(Ljava/lang/Object;)V 
     60: goto   37 
     63: aload_1  
     64: invokevirtual #11     // Method java/util/ArrayList.iterator:()Ljava/util/Iterator; 
     67: astore_2  
     68: aload_2  
     69: invokeinterface #7, 1   // InterfaceMethod java/util/Iterator.hasNext:()Z 
     74: ifeq   92 
     77: getstatic  #9     // Field java/lang/System.out:Ljava/io/PrintStream; 
     80: aload_2  
     81: invokeinterface #8, 1   // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object; 
     86: invokevirtual #10     // Method java/io/PrintStream.println:(Ljava/lang/Object;)V 
     89: goto   68 
     92: return   
} 

线32〜60是第一个环和第63至89行是第二个循环。你会注意到它们几乎是一样的 - 只是一些当地人的名字改变了，并且轻微的重新排序。

因此，由于编译器为两个表达式产生相同的字节码，它们是相同的。