我应该使用迭代器还是 for 循环来迭代?

Posted

技术标签:

【中文标题】我应该使用迭代器还是 for 循环来迭代?【英文标题】:Should I use an Iterator or a forloop to iterate? 【发布时间】:2014-04-27 17:08:55 【问题描述】:

我不喜欢必须调用 hasNext()next() 的想法,并且看到无论如何我需要一个循环来调用它们,我真的不认为使用给我们的迭代器有什么意义在列表和地图中。

仅当您需要从列表中拉出一个时?或者,如果您要从列表中取出一项,并且必须在无法测量的时间内这样做?我在 Google 或 Stack 上找不到这个,请帮帮我。

我不是专门讨论增强的 for 循环(for-each 循环)。

我也知道 foreach 循环在性能方面表现出色,但这更像是一个“它为什么存在”的问题

编辑:意识到我只是在谈论集合而不是数组。 Foreach 循环在这种情况下没有限制。

【问题讨论】:

当你想在迭代时删除时,你必须使用它——你不能用 foreach 循环来做。请注意,“内部”foreach 循环使用迭代器(请参阅 Iterable 的 javadoc)。 for(int i = 0; i < list.length; i++) if(list.get(i).equals("example") list.remove(i); 那不行吗? 它会,是的......我猜是选择问题;)但是你在这里使用的不是foreach循环,它是第三种解决方案:p @VinceEmigh foreachfor 具有性能优势,因为在许多情况下,基于迭代器的访问比基于索引的访问更快。看我的回答。 不,在 for 循环期间修改列表不起作用。假设您有一个列表 (a,b,c,d)。如果删除 a 索引仍会递增,并且使用修改后的列表 (b,c,d),循环的下一次迭代将返回 c 并跳过 b。 【参考方案1】:

foreach 相当于一个迭代器——它是同一事物的语法糖。所以你应该尽可能选择foreach而不是迭代器,因为它很方便并且代码更简洁。

我在另一个答案中写过这个:https://***.com/questions/22110482/uses-and-syntax-for-for-each-loop-in-java/22110517#22110517

正如@RonnyShapiro 所说,在某些情况下您需要使用迭代器,但在许多情况下foreach 就足够了。请注意,foreach不是普通的for 循环。当需要访问索引时,需要正常的for 循环。尽管您可以使用 foreach 手动创建一个单独的索引 int 变量,但从 variable-scope 的角度来看,这并不理想。

这里有更多信息:Which is more efficient, a for-each loop, or an iterator?

访问集合时,foreach 是 significantly faster,而不是基本的 for 循环的数组访问。然而,当访问数组时——至少使用原始数组和包装数组——通过索引进行访问方式更快。见下文。


在访问 intInteger 数组时,索引比迭代器快 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)

完整的测试类:

   import  java.text.NumberFormat;
   import  java.util.Locale;
/**
   <P>@code java TimeIteratorVsIndexIntArray 1000000</P>

   @see  <CODE><A HREF="https://***.com/questions/180158/how-do-i-time-a-methods-execution-in-java">https://***.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 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

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

但是,对于 Integers 中的 List,迭代器更快。只需将上面代码中的int-array改为

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&lt;Integer&gt;lengthsize() 等)

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

在一项测试中,它们几乎是等价的,但迭代器仍然获胜。

【讨论】:

还有一个问题。这是否意味着foreach 是迭代器的替代品?我的意思是,除非您只想获取 1 项,而不是遍历整个列表,否则我看不出有任何使用迭代器的理由。 使用迭代器完全没有问题。 foreach 只是为了方便,当你不需要做任何事情时,除了遍历每个元素,按顺序逐个阅读它们。我实际上会在一分钟内在我的答案中发布更多内容...... 好的,谢谢 :) 我不喜欢你需要一个循环来使用迭代器抓取多个元素。如果出现某种原因,您需要同步 hasNext() next() 执行,而不是列表。它可以占用一些不需要的空间。 (不是记忆,而是视觉) 确切地说:视觉上,实际上不是。我已经更新了我的答案,以比较 foreach/iterator-access 与 index-access 的时间。 我已经把它写成了一篇博文:aliteralmind.wordpress.com/2014/03/22/for_foreach【参考方案2】:

在 Java 5 中添加了 For each,以便更轻松地对集合进行迭代。但是,它不会替换迭代器,因为只有迭代器才能在迭代集合时修改集合(通过迭代器接口)。尝试从 for each 中的集合中添加\删除对象将导致 ConcurrentModificationException。

如果您只是读取值,foreach 可能会更好。

【讨论】:

【参考方案3】:

嗯,Java 语言规范 8(http://docs.oracle.com/javase/specs/jls/se8/jls8.pdf),14.14.2:

增强的 for 语句相当于基本的 for 语句,形式如下:

for (I #i = Expression.iterator(); #i.hasNext(); ) 
    VariableModifier TargetType Identifier =
    (TargetType) #i.next();
    Statement

所以,对于编译器来说也是一样的。 本标准的早期版本包含对“foreach”语句的相同描述

【讨论】:

【参考方案4】:

这部分与 java 随时间发展的历史有关。自 Java 1.2 以来,迭代器是一种语言特性,作为处理对象集合的一种方式。 Java 1.5 添加了可迭代接口和 for-each 循环。

除非您需要在循环期间对迭代器执行特定操作,否则我将始终使用 for-each 块(在实现中使用迭代器)

【讨论】:

【参考方案5】:

通常 Iterator 比使用 objects.get(i) 执行 for 循环要快一点,但差异对您的代码没有实际影响。 Iterator 的主要优点是您可以通过在迭代器上调用 remove 方法从列表中删除一个对象。

【讨论】:

为什么迭代器或 foreach 循环会比另一个更快或更慢? for ( Object x : objects ) ... 就是 for ( Iterator i = objects.iterator() ; i.hasNext() ; ) Object x = i.next(); ... 除非您的意思是带有整数索引的for 循环,并使用objects.get(i),因为如果您使用具有@987654326 的列表会更慢@ 那不是恒定的时间(例如,LinkedList)。不过,这不是一个 foreach 循环,这正是 OP 所要求的。

以上是关于我应该使用迭代器还是 for 循环来迭代?的主要内容,如果未能解决你的问题,请参考以下文章

python-迭代器详解

迭代器和生成器

哪个更有效,for-each 循环还是迭代器?

Python之迭代器和生成器

python 迭代器与生成器

Python全栈开发之---迭代器可迭代对象生成器