java集合迭代器

一、Java中有一个设计模式是迭代器模式

1.迭代器模式定义
迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。

2.迭代器模式概述
Java集合框架的集合类，我们有时候称之为容器。容器的种类有很多种，比如ArrayList、LinkedList、HashSet...，每种容器都有自己的特点，ArrayList底层维护的是一个数组；LinkedList是链表；HashSet依赖的是哈希表，每种容器都有自己特有的数据结构。
因为容器的内部结构不同，在不清楚容器内部结构的情况下很难知道怎样去遍历一个容器中的元素，所以为了简化容器内的元素操作，Java引入了迭代器模式。
迭代器模式把访问逻辑从不同类型的集合类中抽取出来，从而避免想外部暴露集合的内部结构。

3.迭代器模式的角色构成
1）迭代器角色（Iterator）：定义遍历元素需要的方法，一般来说会有三个方法：
next()：取得下一个元素
hasNext()：判断是否遍历结束（是否有下一个元素）
remove()：移除当前对象
2）具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代。
3）容器角色（Aggregate）：一般是一个接口，提供一个iterator()方法，例如Java中的Collection接口，List接口，Set接口等。
4）具体容器角色（ConcreteAggregate）：抽象容器的具体实现类，例如List接口的有序列表实现ArrayList，List接口的链表实现LinList，Set接口的哈希列表的实现HashSet等。

4.迭代器模式应用的场景及意义
1）访问一个聚合对象的内容而无需暴露它的内部表示。
2）支持对聚合对象的多种遍历。
3）为遍历不同的聚合结构提供一个统一的接口。

二、迭代的实现（原理、源码）
1.java.util.Iterator
在Java中Iterator是一个接口，它只提供了迭代的基本规则。在JDK中它是这样定义的：对Collection进行迭代的迭代器。
迭代器取代了Java Collection Framework中的Enumeration。
迭代器与枚举有两点不同：
1）迭代器在迭代期间可以从集合中移除元素。
2）方法名得到了改进，Enumeration的方法名称都比较长。
接口定义：

package java.util;
public interface Iterator<E> {
    boolean hasNext(); // 判断是否存在下一个对象元素
 
    E next(); // 获取下一个元素
 
    void remove(); // 移除元素
}

2.Iterable
Java中还提供了一个Iterable接口，Iterable接口实现的功能是返回一个迭代器，我们常用的实现了该接口的子接口有：Collection<E>、List<E>、Set<E>等。该接口的iterator()方法返回一个标注你的Iterator实现。实现Iterable接口允许对象成为Foreach语句的目标，然后就可以通过Foreach语句来遍历你的底层序列。

Iterable接口包含一个能产生Iterator对象的方法，并且Iterable被Foreach用来在序列中移动。因此如果创建了实现Iterable接口的类，都可以将它用在Foreach循环语句中。

Iterable接口的具体实现：

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

使用Foreach遍历集合：

List<String> names = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
for (String name : names) {
    System.out.println(name);
}

可以看出使用Foreach语句遍历集合的优势在于代码更加的简洁，更不容易出错，不用关心下标的起始值和终止值。

3.Iterator遍历时不可以删除集合中的元素的问题
在使用Iterator的时候禁止对所遍历的容器进行改变其大小结构的操作。例如：在使用Iterator进行迭代时，如果堆集合进行了add、remove操作就会出现ConcurrentModificationException异常。

List<String> names = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
 
// 使用迭代器遍历ArrayList集合
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
    Object obj = iterator.next();
    if ("李四".equals(obj)){
        list.remove(obj);
    }
}

因为在你迭代之前，迭代器已经被通过list.itertor()创建出来了，如果在迭代的过程中，又对list进行了改变其容器大小的操作，那么Java就会给出异常，因为此时Iterator对象已经无法主动同步list做出的改变，Java会认为你做出这样的操作是线程不安全的，就会抛出异常。
Iterator的实现源码：

private class Itr implements Iterator<E> {
    int cursor; // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such element returned
    int expectedModCount = 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();
        }
    }
 
    final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    }
}        

通过查看源码发现原来检查并抛出异常的是checkForComodification()方法。

在ArrayList中，modCount是当前集合的版本号，每次修改（增、删）集合都会加1；expectedModCount是当前迭代器的版本号，在迭代器实例化时初始化为modCount。我们看到在该方法中就是验证这两个值是否相等，所以当你在调用ArrayList.add()或者ArrayLit.remove()时，只更新了modCount的状态，而迭代器中的expectedModCount未同步，因此才会导致再次调用Iterator.next()方法的时候抛出异常。但是为什么使用Iterator.remove()就没有问题呢，通过源码的第32行发现，在Iterator的remove()中同步了expectedModCount的值，所以当你下次再调用next()的时候，检查不会抛出异常。
使用该机制的主要目的是为了实现ArrayList中的快速失败机制（fail-fast），当多个线程对Collection进行操作时，若其中某一个线程通过Iterator遍历集合时，该集合的内容被其他线程所改变，则会抛出ConcurrentModificationException异常。
所以要保证在使用Iterator遍历集合的时候不出错误，就应该保证在遍历集合的过程中不会对集合产生结构上的修改。
上面我们说了实现了Iterable接口的类就可以通过Foreach语句遍历，那是因为Foreach要依赖于Iterable接口返回的Iterator对象，所以从本质上来讲，Foreach其实就是在使用迭代器，在使用Froeach遍历的时候对集合的结构进行修改，和在使用Iterator遍历时堆集合结构进行修改本质上是一样的。所以同样的也会抛出异常，执行快速失败机制。

三、迭代的使用（遍历）
迭代器遍历，就是将集合中的数据放到一个容器中排成一排，Iterator有一个游标，开始遍历时，游标在第一个元素的前面，通过调用Iterator.next()方法，将游标向后移动一位，Iterator.hasNext()方法则是判断游标后面还有没有可以迭代的元素。

1.迭代器（Iterator）遍历List

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
    String next = iterator.next();
    System.out.println(next);
}

2.迭代器（Iterator）遍历Set
因为Set是无序的，所以for循环无法遍历Set，只能用迭代器遍历，导致后面统一用迭代器遍历集合，这就是迭代器的产生（手动滑稽）。

Set<String> set = new HashSet<>();
set.add("a");
set.add("b");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
    String next = iterator.next();
    System.out.println(next);
}

3.迭代器（Iterator）遍历Map
Map中是存放的是键值对，不是像List或者Set那样存放单一元素，所以我们需要先将Map作为单一元素放到Set中，使用JDK中Map提供的entrySet()方法。

Map<Integer,String> map = new HashMap<>();
Set<Map.Entry<Integer, String>> entries = map.entrySet();
Iterator<Map.Entry<Integer, String>> iterator = entries.iterator();
while (iterator.hasNext()){
    Map.Entry<Integer, String> next = iterator.next();
    System.out.println(next);
}