Java集合框架分析(六)-Iterator迭代器分析

時間 2019-11-06

原文原文鏈接

本篇文章主要分析一下Java集合框架中的迭代器部分，Iterator，該源碼分析基於JDK1.8，分析工具，AndroidStudio，文章分析不足之處，還請指正！數組

Java裏面的數組數據能夠經過索引來獲取，那麼對象呢？也是經過索引嗎？今天咱們就來分析一下Java集合中獲取集合對象的方法迭代-Iterator。bash

簡介

咱們經常使用 JDK 提供的迭代接口進行 Java 集合的迭代。框架

Iterator iterator = list.iterator();
         while(iterator.hasNext()){
             String string = iterator.next();
             //do something
         }
複製代碼

上面即是迭代器使用的基本模板，迭代其實咱們能夠簡單地理解爲遍歷，是一個標準化遍歷各種容器裏面的全部對象的方法類。它老是控制 Iterator，向它發送」向前」，」向後」，」取當前元素」的命令，就能夠間接遍歷整個集合。在 Java 中 Iterator 爲一個接口，它只提供了迭代了基本規則：ide

public interface Iterator<E> {
    //判斷容器內是否還有可供訪問的元素
    boolean hasNext();
	//返回迭代器剛越過的元素的引用，返回值是 E
    E next();
	//刪除迭代器剛越過的元素
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
}
複製代碼

上面即是迭代器的基本申明，咱們經過具體的集合來分析。工具

集合分類

ArrayList的Iterator

咱們經過分析ArrayList的源碼能夠知道，在 ArrayList 內部首先是定義一個內部類 Itr，該內部類實現 Iterator 接口，以下：源碼分析

private class Itr implements Iterator<E> {
	//....
}
複製代碼

在內部類實現了Iterator接口，而ArrayList的Iterator是返回的它的內部類Itr，因此咱們主要看看Itr是如何實現的。學習

public Iterator<E> iterator() {
       return new Itr();
   }
複製代碼

接下來咱們分析一下它的內部類Itr的實現方式。ui

private class Itr implements Iterator<E> {
       
       protected int limit = ArrayList.this.size;
       int cursor;       // index of next element to return
       int lastRet = -1; // index of last element returned; -1 if no such
       int expectedModCount = modCount;
       public boolean hasNext() {
           return cursor < limit;
       }
       @SuppressWarnings("unchecked")
       public E next() {
           if (modCount != expectedModCount)
               throw new ConcurrentModificationException();
           int i = cursor;
           if (i >= limit)
               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();
           if (modCount != expectedModCount)
               throw new ConcurrentModificationException();
           try {
               ArrayList.this.remove(lastRet);
               cursor = lastRet;
               lastRet = -1;
               expectedModCount = modCount;
               limit--;
           } 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;
           if (modCount != expectedModCount)
               throw new ConcurrentModificationException();
       }
   }
複製代碼

首先咱們來分析一下定義的變量：this

protected int limit = ArrayList.this.size;
      int cursor;       // index of next element to return
      int lastRet = -1; // index of last element returned; -1 if no such
      int expectedModCount = modCount;
複製代碼

其中，limit是當前ArrayList的大小，cursor表明的是下一個元素的索引，而lastRet是上一個元素的索引，沒有的話就返回-1，expectedModCount沒什麼多大用處。咱們接着分析看迭代的時候怎麼判斷有沒有後繼元素的。spa

public boolean hasNext() {
           return cursor < limit;
   }
複製代碼

很簡單，就是判斷下一個元素的索引有沒有到達數組的容量大小，達到了就沒有了，到頭了！

接着，咱們在分析一下獲取當前索引的元素的方法next

public E next() {
          if (modCount != expectedModCount)
              throw new ConcurrentModificationException();
          int i = cursor;
          if (i >= limit)
              throw new NoSuchElementException();
          Object[] elementData = ArrayList.this.elementData;
          if (i >= elementData.length)
              throw new ConcurrentModificationException();
          cursor = i + 1;
          return (E) elementData[lastRet = i];
      }
複製代碼

在next方法中爲何要判斷modCount呢？即用來判斷遍歷過程當中集合是否被修改過。modCount 用於記錄 ArrayList 集合的修改次數，初始化爲 0，，每當集合被修改一次（結構上面的修改，內部update不算），如 add、remove 等方法，modCount + 1，因此若是 modCount 不變，則表示集合內容沒有被修改。該機制主要是用於實現 ArrayList 集合的快速失敗機制，在 Java 的集合中，較大一部分集合是存在快速失敗機制的。因此要保證在遍歷過程當中不出錯誤，咱們就應該保證在遍歷過程當中不會對集合產生結構上的修改（固然 remove 方法除外），出現了異常錯誤，咱們就應該認真檢查程序是否出錯而不是 catch 後不作處理。上面的代碼比較簡單，就是返回索引處的數組值。

對於ArrayList的迭代方法，主要是判斷索引的值和數組的大小進行比較，看看尚未數據能夠遍歷了，而後再依次獲取數組中的值，而已，主要抓住各個集合的底層實現方式便可進行迭代。

接下來咱們在分析一下HashMap的Iterator的方法，其餘方法相似，只要抓住底層實現方式便可。

HashMap的Iterator

在HashMap中，也有一個類實現了Iterator接口，只不過是個抽象類，HashIterator，咱們來看看它的實現方式。

private abstract class HashIterator<E> implements Iterator<E> {
       HashMapEntry<K,V> next;        // next entry to return
       int expectedModCount;   // For fast-fail
       int index;              // current slot
       HashMapEntry<K,V> current;     // current entry
       HashIterator() {
           expectedModCount = modCount;
           if (size > 0) { // advance to first entry
               HashMapEntry[] t = table;
               while (index < t.length && (next = t[index++]) == null)
                   ;
           }
       }
       public final boolean hasNext() {
           return next != null;
       }
       final Entry<K,V> nextEntry() {
           if (modCount != expectedModCount)
               throw new ConcurrentModificationException();
           HashMapEntry<K,V> e = next;
           if (e == null)
               throw new NoSuchElementException();
           if ((next = e.next) == null) {
               HashMapEntry[] t = table;
               while (index < t.length && (next = t[index++]) == null)
                   ;
           }
           current = e;
           return e;
       }
       public void remove() {
           if (current == null)
               throw new IllegalStateException();
           if (modCount != expectedModCount)
               throw new ConcurrentModificationException();
           Object k = current.key;
           current = null;
           HashMap.this.removeEntryForKey(k);
           expectedModCount = modCount;
       }
   }
複製代碼

一樣，它也定義了一個變量

HashMapEntry<K,V> next;        // next entry to return
      int expectedModCount;   // For fast-fail
      int index;              // current slot
      HashMapEntry<K,V> current;     // current entry
複製代碼

next表明下一個entry的節點，expectedModCount一樣是用於判斷修改狀態，用於集合的快速失敗機制。index表明當前索引，current當前所索引所表明的節點entry，咱們來看看如何判斷是否還有下一個元素的值的。

public final boolean hasNext() {
          return next != null;
      }
複製代碼

很簡單就是判斷next是否爲null，爲null的話就表明沒有數據了。

接着分析獲取元素的方法

final Entry<K,V> nextEntry() {
          if (modCount != expectedModCount)
              throw new ConcurrentModificationException();
          HashMapEntry<K,V> e = next;
          if (e == null)
              throw new NoSuchElementException();
	// 一個Entry就是一個單向鏈表
          // 若該Entry的下一個節點不爲空，就將next指向下一個節點;
          // 不然，將next指向下一個鏈表(也是下一個Entry)的不爲null的節點。
          if ((next = e.next) == null) {
              HashMapEntry[] t = table;
              while (index < t.length && (next = t[index++]) == null)
                  ;
          }
          current = e;
          return e;
      }
複製代碼

以上即是一些具體集合實例的迭代方法實現原理，同理能夠分析其餘集合的實現方式。