1. 区别

1.1 在形式上

  • for的形式是

for（int i=0;i<arr.size();i++）{...}

  • foreach的形式是

for（int　i：arr）{...}

  • iterator的形式是
    1. Iterator it = arr.iterator();
    2. while(it.hasNext()){ 
    3.   object o =it.next(); 
    4.   // ...
    5. }

或者：

  1. // 删除ArrayList中重复元素，保持顺序
  2. public static void removeDuplicateWithOrder(List list) {
  3.     Set set = new HashSet();
  4.     List newList = new ArrayList();
  5.     for (Iterator iter = list.iterator(); iter.hasNext(); ) {
  6.         Object element = iter.next();
  7.         if (set.add(element))
  8.             newList.add(element);
  9.     }
  10.     list.clear();
  11.     list.addAll(newList);
  12. }

1.2 条件上

  • for 需要知道集合或数组的大小，而且需要是有序的，不然无法遍历；
  • foreach 和 iterator 都不需要知道集合或数组的大小，他们都是得到集合内的每个元素然后进行处理；

    1.3 多态差别

    for 和 foreach 都需要先知道集合的类型，甚至是集合内元素的类型，即需要访问内部的成员，不能实现态；
    iterator 是一个接口类型，他不关心集合或者数组的类型，而且他还能随时修改和删除集合的元素，举个例子：
  1. public void display（Iterator<object> it）{
  2.     while(it.hasNext()){
  3.         system.out.print(it.next()+"");
  4.     }
  5.  }

当我们需要遍历不同的集合时，我们只需要传递集合的 iterator（如arr.iterator()）看懂了吧，这就是iterator的好处，他不包含任何有关他所遍历的序列的类型信息，能够将遍历序列的操作与序列底层的结构分离。迭代器统一了对容器的访问方式。这也是接口的解耦的最好体现。

1.4 用法差别

  • for 循环一般用来处理比较简单的有序的，可预知大小的集合或数组
  • foreach 可用于遍历任何集合或数组，而且操作简单易懂，他唯一的不好就是需要了解集合内部类型
  • iterator 是最强大的，他可以随时修改或者删除集合内部的元素，并且是在不需要知道元素和集合的类型的情况下进行的（原因可参考第三点：多态差别），当你需要对不同的容器实现同样的遍历方式时，迭代器是最好的选择！

    2. 效率对比

    ```java private static final int COUNT = 10000; private static List persons = new LinkedList<>();

public static void init() { //初始化，生成对象个数 Person person; for (int i = 0; i < COUNT; i++) { person = new Person(i, “张三” + i, i + “”); persons.add(person); } }

//Iterator遍历 public static long testIterator() { //开始编译执行时间 long start = System.nanoTime(); Person person = null; for (Iterator iterator = persons.iterator(); iterator.hasNext(); ) { person = (Person) iterator.next();

  1. }
  2. //执行完后的时间
  3. long end = System.nanoTime();
  4. return (end - start) / (1000);

}

//foEach循环遍历 public static long testForEach() { //开始编译执行时间 long start = System.nanoTime(); Person person = null; for (Person p : persons) { person = p; } //执行完后的时间 long end = System.nanoTime(); return (end - start) / (1000); }

//for循环遍历 public static long testFor() { //开始编译执行时间 long start = System.nanoTime(); Person person = null; for (int i = 0; i < persons.size() ; i++) { person = persons.get(i); } //执行完后的时间 long end = System.nanoTime(); return (end - start) / (1000); }

public static void main(String[] args) { init(); System.out.println(“Iterator迭代遍历的消耗时间为:” + testIterator()); System.out.println(“ForEach遍历的消耗时间为:” + testForEach()); System.out.println(“For循环遍历的消耗时间为:” + testFor());

}

  2. - 当集合为 ArrayList 的时候，效率对比：**`forEach > for > Iterator`**
  3. ```java
  4. Iterator迭代遍历的消耗时间为:1583
  5. ForEach遍历的消耗时间为:765
  6. For循环遍历的消耗时间为:1072
  • 当集合为 LinkedList 的时候，效率对比：forEach > Iterator >> for
    1. Iterator迭代遍历的消耗时间为:1464
    2. ForEach遍历的消耗时间为:811
    3. For循环遍历的消耗时间为:260728