java 中 Iterator 和 Iterable 区别

Iterator（迭代器）

作为一种设计模式，迭代器可以用于遍历一个对象，而开发人员不用去了解这个对象的底层结构。这里就不仔细说迭代器这种设计模式，因为我们主要的目的是探索java中Iterator和 Iterable之间的区别

用法

首先来说一下他们各自是怎么使用，不会用谈什么都是瞎搞。

Iterator用法

首先来说一下Iterator这个接口，他定义了迭代器基本的功能。

源码如下

package java.util;public interface Iterator<E> {    boolean hasNext();   //返回是否有下一个元素    E next();            //返回下一个元素    void remove();       //移除当前元素}

如何使用这个接口

public class main {    public static void main(String[] args) {        MyIterator mi = new MyIterator();        while (mi.hasNext()){            System.out.printf("%s\t",mi.next());        }    }}class MyIterator implements Iterator<String>{    private String[] words = ("And that is how "            + "we know the Earth to be banana-shaped.").split(" ");    private int count = 0;    public MyIterator() {    }    @Override    public boolean hasNext() {        return count < words.length;    }    @Override    public String next() {        return words[count++];    }}

代码很简单，所以就不过多的解释了，但是有一点需要注意的是，下面这样使用上面定义的MyIterator类是错误的，你可以试一下。

for (String s:new MyIterator){            System.out.printf("%s\t",s); }

Iterable用法

源码

package java.lang;import java.util.Iterator;public interface Iterable<T> {    Iterator<T> iterator();   }

如何使用

public class main {    public static void main(String[] args) {      MyIterable myIterable= new MyIterable();        Iterator<String> mIterator = myIterable.iterator();        for (String s:myIterable){            System.out.printf("%s\t",s);        }    }}class MyIterable implements Iterable<String>{    private String[] words = ("And that is how "            + "we know the Earth to be banana-shaped.").split(" ");    @Override    public Iterator<String> iterator() {        return new Iterator<String>() {            private int i = 0;            @Override            public boolean hasNext() {                return i < words.length;            }            @Override            public String next() {                return words[i++];            }        };    }}

与上面Iterator不同的是，这个类还可以下面这样使用

        MyIterable mi = new MyIterable().iterator();        while (mi.hasNext()){            System.out.printf("%s\t",mi.next());        }

区别

基本用法已经说完，相信你也能看出其中的一些区别

1. Iterator是迭代器类(这个类是指定义了迭代器基本需要的方法)，而Iterable是接口。 这个从他们的包名就可以看出来。

java.lang.Iterable java.util.Iterator 

1. Iterator不嫩用于foreach循环语句，Iterable可以

2. 为什么一定要实现Iterable接口，为什么不直接实现Iterator接口呢？

   看一下JDK中的集合类，比如List一族或者Set一族，都是实现了Iterable接口，但并不直接实现Iterator接口。这并不是没有道理的。因为Iterator接口的核心方法next()或者hasNext() 是依赖于迭代器的当前迭代位置的。如果Collection直接实现Iterator接口，势必导致集合对象中包含当前迭代位置的数据(指针)。当集合在不同方法间被传递时，由于当前迭代位置不可预置，那么next()方法的结果会变成不可预知。 除非再为Iterator接口添加一个reset()方法，用来重置当前迭代位置。但即时这样，Collection也只能同时存在一个当前迭代位置。而Iterable则不然，每次调用都会返回一个从头开始计数的迭代器。多个迭代器是互不干扰的。

扩展

你在看ArrayList源码的时候，你会发现这样一段代码

   private class Itr implements Iterator<E> {       int cursor;       // 返回下一个元素的索引      int lastRet = -1; // 返回最后一个元素的索引，如果空，返回-1       int expectedModCount = modCount; //用于检测当前集合是否执行了添加删除操作，其中modCount，是当前集合中元素的个数       public boolean hasNext() {           return cursor != size;       }       @SuppressWarnings("unchecked")       public E next() {           checkForComodification(); //检测集合元素是否执行添加删除操作           int i = cursor;           if (i >= size)               throw new NoSuchElementException();           Object[] elementData = ArrayList.this.elementData;           if (i >= elementData.length)               throw new ConcurrentModificationException();           cursor = i + 1;           return (E) elementData[lastRet = i];       }       public void remove() {           if (lastRet < 0)               throw new IllegalStateException();           checkForComodification();           try {               ArrayList.this.remove(lastRet);               cursor = lastRet;               lastRet = -1;               expectedModCount = modCount;           } catch (IndexOutOfBoundsException ex) {               throw new ConcurrentModificationException();           }       }       @Override       @SuppressWarnings("unchecked")       public void forEachRemaining(Consumer<? super E> consumer) {           Objects.requireNonNull(consumer);           final int size = ArrayList.this.size;           int i = cursor;           if (i >= size) {               return;           }           final Object[] elementData = ArrayList.this.elementData;           if (i >= elementData.length) {               throw new ConcurrentModificationException();           }           while (i != size && modCount == expectedModCount) {               consumer.accept((E) elementData[i++]);           }           // update once at end of iteration to reduce heap write traffic           cursor = i;           lastRet = i - 1;           checkForComodification();       }      //如果发生添加删除操作，则抛出错误。       final void checkForComodification() {           if (modCount != expectedModCount)               throw new ConcurrentModificationException();       }   }

​ 对于上述的代码不难看懂，有点疑惑的是int expectedModCount = modCount;这句代码

​ 其实这是集合迭代中的一种“快速失败”机制，这种机制提供迭代过程中集合的安全性。阅读源码

​ 就可以知道ArrayList中存在modCount对象，增删操作都会使modCount++，通过两者的对比

​ 迭代器可以快速的知道迭代过程中是否存在list.add()类似的操作，存在的话快速失败!

Fail-Fast(快速失败)机制

仔细观察上述的各个方法，我们在源码中就会发现一个特别的属性modCount，API解释如下：

​ The number of times this list has been structurally modified. Structural modifications are those that change the size of the list, or otherwise perturb it in such a fashion that iterations in progress
may yield incorrect results.

记录修改此列表的次数：包括改变列表的结构，改变列表的大小，打乱列表的顺序等使正在进行 迭代产生 错误的结果。

Tips:仅仅设置元素的值并不是结构的修改

我们知道的是ArrayList是线程不安全的，如果在使用迭代器的过程中有其他的线程修改了List就会

抛出ConcurrentModificationException这就是Fail-Fast机制。

那么快速失败究竟是个什么意思呢？

在ArrayList类创建迭代器之后，除非通过迭代器自身remove或add对列表结构进行修改，否则在其他

​ 线程中以任何形式对列表进行修改，迭代器马上会抛出异常，快速失败。

迭代器的好处

迭代器的好处

​ 通过上述我们明白了迭代是到底是个什么，迭代器的使用也十分的简单。现在简要的总结下使用迭代器的好处吧。

1. 迭代器可以提供统一的迭代方式。**
2. 迭代器也可以在对客户端透明的情况下，提供各种不同的迭代方式。

不过对于第三点尚需注意的是：就像上述事例代码一样，我们不能保证迭代过程中出现“快速失败”的都是因为同步造成的，因此为了保证迭代操作的正确性而去依赖此类异常是错误的！