为什么推荐使用For-Each而不是For循环遍历元素？

for循环是平时写代码用的最多的，但是之前看《Effective java》，大佬在某些场景写并不推荐。结合着自己之前刷算法题的经历，受益匪浅。

思礼网站建设公司创新互联公司,思礼网站设计制作，有大型网站制作公司丰富经验。已为思礼上1000+提供企业网站建设服务。企业网站搭建\成都外贸网站制作要多少钱，请找那个售后服务好的思礼做网站的公司定做！

一、for循环的缺点

在以往遍历元素的时候，我们通常采用以下的形式：

 
 
 
 
  
  
  
  public class Main { 
  
  
  
   public static void main(String[] args) { 
  
  
  
    //1、数组元素 
  
  
  
    int[] num = new int[] {1,2,3,4,5}; 
  
  
  
    //数组的遍历 
  
  
  
    for(int i=0;i
  
  
  
  
   System.out.println(num[i]); 
  
  
  
    //2、对象元素 
  
  
  
    ArrayList lists = new ArrayList<>(); 
  
  
  
    lists.add(new Person("张三")); 
  
  
  
    lists.add(new Person("李四")); 
  
  
  
    lists.add(new Person("愚公要移山")); 
  
  
  
    //对象元素的遍历 
  
  
  
    for(Iterator it=lists.iterator();it.hasNext();) { 
  
  
  
     Person p = it.next(); 
  
  
  
     System.out.println(p.getName()); 
  
  
  
    } 
  
  
  
   } 
  
  
  
  }

这种写法看起来还不错，但是却并不完美。我们来分析一下，有什么缺点。然后给出解决方案。

问题1：迭代器或索引多次出现，容易造成使用错误

从上面两种遍历的代码上来看，对于数组元素是通过索引i来遍历的，但是整个for循环出现了四次i，对于对象元素是通过迭代器it来遍历的，但是整个for循环出现了三次it。在for循环遍历元素的时候，就有多次机会使用了错误的变量。而且有时候这些错误编译器无法发现。对整个应用系统造成无法预知的错误。

问题2：遍历对象元素时，需要注意容器类型

比如我们这里使用的是list，当然还有可能是其他容器类型，这些类型在更改时比较麻烦。

问题3：嵌套迭代抛出异常

这种情况比较复杂一些，先来搞个例子。比如说，我们想要列举每种花，这些花有两种属性一种是颜色，一种是大小。

 
 
 
 
  
  
  
  public class Main { 
  
  
  
   //枚举颜色和尺寸 
  
  
  
   enum Color { RED, GREEN, BLUE, BLACK } 
  
  
  
   enum Size { ONE, TWO, THREE, FOUR, FIVE, 
  
  
  
      SIX, SEVEN, EIGHT,NINE, TEN} 
  
  
  
   //定义花 
  
  
  
   static class Flower{ 
  
  
  
    public Flower(Color color, Size size) {} 
  
  
  
   } 
  
  
  
   public static void main(String[] args) { 
  
  
  
    Collection colors = Arrays.asList(Color.values()); 
  
  
  
    Collection sizes = Arrays.asList(Size.values()); 
  
  
  
    List flowers = new ArrayList<>(); 
  
  
  
    //for循环添加所有的花和尺寸 
  
  
  
    for (Iterator color = colors.iterator(); color.hasNext(); ) { 
  
  
  
     for (Iterator size = sizes.iterator(); size.hasNext(); ) { 
  
  
  
      flowers.add(new Flower(color.next(), size.next())); 
  
  
  
     }  
  
  
  
    }  
  
  
  
   } 
  
  
  
  }

看似人畜无害，现在我们运行一波。

 
 
 
 
  
  
  
  Exception in thread "main" java.util.NoSuchElementException 
  
  
  
   at java.util.AbstractList$Itr.next(Unknown Source) 
  
  
  
   at com.f2.Main.main(Main.java:25)

是不是感觉有点奇怪，好像双重循环遍历没啥问题，但是出现了异常，原因是外部的Color迭代器调用了多次，第一层for循环被调用了，但是又在第二层for循环内部被调用了，所以color的next被调用完了。所以出现了NoSuchElementException。但是有时候也不会出现这种情况，场景是外部循环迭代器调用的次数刚好是内部调用的n倍。

问题4：嵌套迭代不抛异常，但是结果不正确

这种情况是外部循环迭代器调用的次数刚好是内部调用的n倍。我们再来个例子：

 
 
 
 
  
  
  
  public class Main { 
  
  
  
   //枚举颜色 
  
  
  
   enum Color { RED, GREEN, BLUE, BLACK }  
  
  
  
   public static void main(String[] args) { 
  
  
  
    Collection colors = Arrays.asList(Color.values()); 
  
  
  
    //两层for循环 
  
  
  
    for (Iterator c1 = colors.iterator(); c1.hasNext(); ) { 
  
  
  
     for (Iterator c2 = colors.iterator(); c2.hasNext(); ) { 
  
  
  
      System.out.println(c1.next()+" "+c2.next()); 
  
  
  
     }  
  
  
  
    }  
  
  
  
   } 
  
  
  
  }

现在对颜色进行for循环遍历，一共两层for循环，因为一共有四种颜色，两层for循环应该是打印16个结果。现在运行一遍看看结果：

 
 
 
 
  
  
  
  RED RED 
  
  
  
  GREEN GREEN 
  
  
  
  BLUE BLUE 
  
  
  
  BLACK BLACK

没错，确实是打印了四条。原因和问题三是一样的。有一种方式可以很好地解决这种嵌套的问题。

嵌套迭代问题解决：

直接看代码。既然是外部的迭代器it在内部使用了，那我在内部和外部之间用一个变量缓存起来不就好了。

 
 
 
 
  
  
  
  public class Main { 
  
  
  
   //枚举颜色 
  
  
  
   enum Color { RED, GREEN, BLUE, BLACK } 
  
  
  
   public static void main(String[] args) { 
  
  
  
    Collection colors = Arrays.asList(Color.values()); 
  
  
  
    //for循环 
  
  
  
    for (Iterator c1 = colors.iterator(); c1.hasNext(); ) { 
  
  
  
     //用一个变量缓存起来 
  
  
  
     Color c = c1.next(); 
  
  
  
     for (Iterator c2 = colors.iterator(); c2.hasNext(); ) { 
  
  
  
      System.out.println(c+" "+c2.next()); 
  
  
  
     }  
  
  
  
    }  
  
  
  
   } 
  
  
  
  }

现在再来运行，就可以很好地得出16种结果了。这种方式也比较不错，但是却不能很好地解决问题1和问题2。因此，为了解决这一现象，大佬Joshua Bloch在书中提出，推荐使用for-each循环来代替for循环。

二、for-each循环

既然作者推荐使用for-each循环，我们看看他有什么好处。是如何解决上面的问题的。

 
 
 
 
  
  
  
  public class Main { 
  
  
  
   //枚举颜色和尺寸 
  
  
  
   enum Color { RED, GREEN, BLUE, BLACK } 
  
  
  
   enum Size { ONE, TWO, THREE, FOUR, FIVE, 
  
  
  
      SIX, SEVEN, EIGHT,NINE, TEN} 
  
  
  
   //定义花 
  
  
  
   static class Flower{ 
  
  
  
    public Flower(Color color, Size size) {} 
  
  
  
   } 
  
  
  
   public static void main(String[] args) { 
  
  
  
    Collection colors = Arrays.asList(Color.values()); 
  
  
  
    Collection sizes = Arrays.asList(Size.values()); 
  
  
  
    List flowers = new ArrayList<>(); 
  
  
  
    //for-each循环 
  
  
  
    for (Color color:colors) { 
  
  
  
     for (Size size:sizes ) { 
  
  
  
      flowers.add(new Flower(color, size)); 
  
  
  
     }  
  
  
  
    }  
  
  
  
   } 
  
  
  
  }

看里面的for-each循环。上面的问题就全都解决了。好吧，可能你会感觉，就这?还有一个好处还没说，再往下看。

for-each 循环不仅允许遍历集合和数组，还允许遍历实现 Iterable 接口的任何对象，该接口由单个方法组成。接口定义如下：

 
 
 
 
  
  
  
  public interface Iterable { 
  
  
  
   // Returns an iterator over the elements in this iterable 
  
  
  
   Iterator iterator(); 
  
  
  
  }

如果必须从头开始编写自己的 Iterator 实现，那么实现 Iterable 会有点棘手，但是如果你正在编写表示一组元素的类型，那么你应该强烈考虑让它实现 Iterable 接口，甚至可以选择不让它实现 Collection 接口。这允许用户使用for-each 循环遍历类型，他们会永远感激不尽的。

但是，有三种常见的情况是你不能分别使用 for-each 循环的:

(1)有损过滤(Destructive filtering)：如果需要遍历集合，并删除指定选元素，则需要使用显式迭代器，以便可以调用其 remove 方法。通常可以使用在 Java 8 中添加的 Collection 类中的 removeIf 方法，来避免显式遍历。

(2)转换：如果需要遍历一个列表或数组并替换其元素的部分或全部值，那么需要列表迭代器或数组索引来替换元素的值。

(3)并行迭代：如果需要并行地遍历多个集合，那么需要显式地控制迭代器或索引变量，以便所有迭代器或索引变量都可以同步进行。

如果发现自己处于这些情况中的任何一种，请使用传统的 for 循环，并警惕本条目中提到的陷阱。

本文转载自微信公众号「愚公要移山」，可以通过以下二维码关注。转载本文请联系愚公要移山公众号。

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：创新互联

猜你还喜欢下面的内容