【Java】 Iterator（迭代器）

一、Iterator介紹

　　Java Iterator（迭代器）不是一個集合，它是一種用於訪問集合的方法，可用於迭代 ArrayList 和 HashSet 等集合。

　　Iterator 是 Java 迭代器最簡單的實現，ListIterator 是 Collection API 中的接口， 它擴展了 Iterator 接口。

Iterator 類圖

　　

　　迭代器 it 的兩個基本操作是 next 、hasNext 和 remove。

　　調用 it.next() 會返回迭代器的下一個元素，並且更新迭代器的狀態。

　　調用 it.hasNext() 用於檢測集合中是否還有元素。

　　調用 it.remove() 將迭代器返回的元素刪除。

　　Iterator 類位於 java.util 包中，使用前需要引入它，語法格式如下：

import java.util.Iterator; // 引入 Iterator 類

二、Iterator使用

1、獲取一個迭代器

　　集合想獲取一個迭代器可以使用 iterator() 方法:

// 引入 ArrayList 和 Iterator 類
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {

        // 創建集合
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");

        // 獲取迭代器
        Iterator<String> it = sites.iterator();

        // 輸出集合中的第一個元素
        System.out.println(it.next());
    }
}

2、循環集合元素

　　讓迭代器 it 逐個返回集合中所有元素最簡單的方法是使用 while 循環：

while(it.hasNext()) {
    System.out.println(it.next());
}

　　以下輸出集合 sites 中的所有元素：

// 引入 ArrayList 和 Iterator 類
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {

        // 創建集合
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");

        // 獲取迭代器
        Iterator<String> it = sites.iterator();

        // 輸出集合中的所有元素
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

3、刪除元素

　　要刪除集合中的元素可以使用 remove() 方法。

　　以下實例我們刪除集合中小於 10 的元素：

// 引入 ArrayList 和 Iterator 類
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(12);
        numbers.add(8);
        numbers.add(2);
        numbers.add(23);
        Iterator<Integer> it = numbers.iterator();
        while(it.hasNext()) {
            Integer i = it.next();
            if(i < 10) {  
                it.remove();  // 刪除小於 10 的元素
            }
        }
        System.out.println(numbers);
    }
}

二、ArrayList中Iterator實現原理

　　最好先弄懂ArrayList實現原理：【Java】ArrayList 的實現原理

1、ArrayList 中 Interator 創建

　　如下：

public Iterator<E> iterator() {
    return new Itr();
}

　　它是創建了一個 ArrayList.Itr 對象

private class Itr implements Iterator<E> {
    // 游標，默認為0，是下一個要返回元素的標
    int cursor;       // index of next element to return
    // 最后返回元素的下標，默認為-1
    int lastRet = -1; // index of last element returned; -1 if no such
    // 期望的集合修改次數，默認為集合的修改次數
    int expectedModCount = modCount;


    Itr() {}

    ......
}

2、 Interator 的 hasNext() 方法

public boolean hasNext() {
    // 游標不等於集合大小
    return cursor != size;
}

3、 Interator 的 next() 方法

// 返回下一個元素
public E next() {
    // 檢查集合是否被修改
    //同個期望的集合修改次數 是否相同比較，這里也就是集合fastfail機制
    checkForComodification();
    // 需要返回元素的下標就是 cursor的值
    int i = cursor;
    if (i >= size)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    // 游標 + 1
    cursor = i + 1;
    // 給 lastRet 賦值，並且返回對應元素
    return (E) elementData[lastRet = i];
}

4、 Interator 的 remove() 方法

// 移除一個當前迭代元素
public void remove() {
    if (lastRet < 0)
        throw new IllegalStateException();
    // 檢查集合是否被修改
    checkForComodification();

    try {
        // 調用集合對象的remove方法
        ArrayList.this.remove(lastRet);
        // 修改游標，指向當前位置
        cursor = lastRet;
        // 最后返回元素的下標，設為-1
        lastRet = -1;
        // 重新獲取集合修改次數
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

5、 Interator 的checkForComodification() 方法

// 檢查集合是否被修改
// 同個期望的集合修改次數 是否相同比較，這里也就是集合fastfail機制
final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

　　期望的集合修改次數 是否被修改，這里也就是集合fast-fail機制

　　在ArrayList介紹中有這么一段話：

注意，迭代器的快速失敗行為無法得到保證，因為一般來說，不可能對是否出現不同步並發修改做出任何硬性保證。快速失敗迭代器會盡最大努力拋出 ConcurrentModificationException。因此，為提高這類迭代器的正確性而編寫一個依賴於此異常的程序是錯誤的做法：迭代器的快速失敗行為應該僅用於檢測 bug。

三、HashSet（HashMap）中Iterator實現原理

　　最好先弄懂HashMap實現原理：【Java】HashMap 的實現原理

1、HasSet 中 Interator 創建

// 創建iterator
public Iterator<E> iterator() {
    // 使用hashmap中的keySet方法返回的keySet集合對象
    // 通過keySet集合對象調用iterator()，返回迭代器
    return map.keySet().iterator();
}

　　 由於HashSet底層使用的是HashMap，所有map.keySet()，返回的是hashMap對象的Set集合，如下：

// keySet() 方法
public Set<K> keySet() {
    Set<K> ks = keySet;
    if (ks == null) {
        // 第一調用創建會去新建一個KeySet對象
        ks = new KeySet();
        keySet = ks;
    }
    return ks;
}

　　而KeySet對象，的iterator() 方法，每次調用都會創建一個KeyIterator對象

final class KeySet extends AbstractSet<K> {
    .......

        // 新建一個KeyIterator對象返回
        public final Iterator<K> iterator()     { return new KeyIterator(); }

    .......
}

　　KeyIterator對象繼承了HashIterator

final class KeyIterator extends HashIterator
    implements Iterator<K> {
    public final K next() { return nextNode().key; }
}

　　查看HashIterator，方向迭代器基本實現在這里

abstract class HashIterator {
        // 下一個要返回的節點
        Node<K,V> next;        // next entry to return
        // 當前節點
        Node<K,V> current;     // current entry
        // 期望集合修改次數
        int expectedModCount;  // for fast-fail
        // 在數組中的當前槽位
        int index;             // current slot

        // 構造方法
        HashIterator() {
            expectedModCount = modCount;
            Node<K,V>[] t = table;
            current = next = null;
            index = 0;
            // 當數組不空 且 集合大小大於0
            if (t != null && size > 0) { // advance to first entry
                // 找到第一個有數據的槽位
                do {} while (index < t.length && (next = t[index++]) == null);
            }
        }
    .......
}

2、 Interator 的 hasNext() 方法

// 是否還有下一個元素
public final boolean hasNext() {
    return next != null;
}

3、 Interator 的 next() 方法

// 返回下一個元素
public final K next() { return nextNode().key; }

// 下一個節點
final Node<K,V> nextNode() {
    Node<K,V>[] t;
    // e 指向 next
    Node<K,V> e = next;
    // 檢查集合是否被修改
    //同個期望的集合修改次數 是否相同比較，這里也就是集合fastfail機制
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    if (e == null)
        throw new NoSuchElementException();
    // 判斷下一個元素是否為空
    if ((next = (current = e).next) == null && (t = table) != null) {
        // 在數組中的當前槽位 + 1
        // 找到下一個有數據的槽位
        do {} while (index < t.length && (next = t[index++]) == null);
    }
    return e;
}

4、 Interator 的 remove() 方法

// 移除一個當前迭代元素
public final void remove() {
    Node<K,V> p = current;
    if (p == null)
        throw new IllegalStateException();
    // 檢查集合是否被修改
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    current = null;
    K key = p.key;
    // 調用hashMap中的removeNode 方法，移除元素
    removeNode(hash(key), key, null, false, false);
    // 重新獲取集合修改次數
    expectedModCount = modCount;
}

　　modCount集合修改次數，這里也就是集合fast-fail機制

　　在HashMap介紹中有這么一段話：

注意，迭代器的快速失敗行為不能得到保證，一般來說，存在非同步的並發修改時，不可能作出任何堅決的保證。快速失敗迭代器盡最大努力拋出 ConcurrentModificationException。因此，編寫依賴於此異常的程序的做法是錯誤的，正確做法是：迭代器的快速失敗行為應該僅用於檢測程序錯誤。 

fast-fail機制解決方案

　　造成fast-fail 原因，基本是多線程操作集合引起的，解決fast-fail問題，即使解決集合安全問題

　　1、方案一：集合安全問題，可以使用synchronzied關鍵字

　　2、方案二：使用Collections.synchronizedList()、Collections.synchronizedMap()

　　3、方案三：使用其他安全集合，比如：CopyOnWriteArrayList、ConcurrentHashMap

 

參考：https://www.runoob.com/java/java-iterator.html