HashMap源碼分析（基於JDK1.6）

    在Java集合類中最常用的除了ArrayList外，就是HashMap了。本文盡自己所能，盡量詳細的解釋HashMap的源碼。一山還有一山高，有不足之處請之處，定感謝指定並及時修正。

    在看HashMap源碼之前先復習一下數據結構。

    Java最基本的數據結構有數組和鏈表。數組的特點是空間連續（大小固定）、尋址迅速，但是插入和刪除時需要移動元素，所以查詢快，增加刪除慢。鏈表恰好相反，可動態增加或減少空間以適應新增和刪除元素，但查找時只能順着一個個節點查找，所以增加刪除快，查找慢。有沒有一種結構綜合了數組和鏈表的優點呢？當然有，那就是哈希表（雖說是綜合優點，但實際上查找肯定沒有數組快，插入刪除沒有鏈表快，一種折中的方式吧）。一般采用拉鏈法實現哈希表。哈希表？拉鏈法？可能一下想不起來，不過放張圖就了然了。

    （圖片google來的，好多都用了文章用了這張圖了，不知道出處了就沒申明作者了）

    學計算機的肯定學過這玩意兒，也不需要解釋，都懂的。

    鋪墊了這么多，又是數組又是鏈表，還有哈希表，拉鏈法，該入正題了，我們什么時候用到了這些內容，具體它是怎么實現的？

    其實我們一直在用（別告訴我你沒用過HashMap什么的），可能你一直沒去深究，沒看到它如何實現的，所以一直沒感受到。這里主要分析HashMap的源碼，就不再多扯其他的了。

    HashMap繼承自AbstractMap，實現了Map接口（這些內容可以參考《Java集合類》）。來看類的定義。

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

    Map接口定義了所有Map子類必須實現的方法。Map接口中還定義了一個內部接口Entry（為什么要弄成內部接口？改天還要學習學習）。Entry將在后面有詳細的介紹。

    AbstractMap也實現了Map接口，並且提供了兩個實現Entry的內部類：SimpleEntry和SimpleImmutableEntry。

    定義了接口，接口中又有內部接口，然后有搞了個抽象類實現接口，抽象類里面又搞了兩個內部類實現接口的內部接口，有沒有點繞，為什么搞成這樣呢？先不管了，先看HashMap吧。

    HashMap中定義的屬性（應該都能看明白，不過還是解釋一下）：

/**
     * 默認的初始容量，必須是2的冪。
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16;
    /**
     * 最大容量（必須是2的冪且小於2的30次方，傳入容量過大將被這個值替換）
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;
    /**
     * 默認裝載因子，這個后面會做解釋
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    /**
     * 存儲數據的Entry數組，長度是2的冪。看到數組的內容了，接着看數組中存的內容就明白為什么博文開頭先復習數據結構了
     */
    transient Entry[] table;
    /**
     * map中保存的鍵值對的數量
     */
    transient int size;
    /**
     * 需要調整大小的極限值（容量*裝載因子）
     */
    int threshold;
    /**
     *裝載因子
     */
    final float loadFactor;
    /**
     * map結構被改變的次數
     */
    transient volatile int modCount;

    接着是HashMap的構造方法。

/**
     *使用默認的容量及裝載因子構造一個空的HashMap
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);//計算下次需要調整大小的極限值
        table = new Entry[DEFAULT_INITIAL_CAPACITY];//根據默認容量（16）初始化table
        init();
    }
/**
     * 根據給定的初始容量的裝載因子創建一個空的HashMap
     * 初始容量小於0或裝載因子小於等於0將報異常 
     */
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)//調整最大容量
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        int capacity = 1;
        //設置capacity為大於initialCapacity且是2的冪的最小值
        while (capacity < initialCapacity)
            capacity <<= 1;
        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
        init();
    }
/**
     *根據指定容量創建一個空的HashMap
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);//調用上面的構造方法，容量為指定的容量，裝載因子是默認值
    }
/**
     *通過傳入的map創建一個HashMap，容量為默認容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的較大者，裝載因子為默認值
     */
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        putAllForCreate(m);
    }

    上面的構造方法中調用到了init()方法，最后一個方法還調用了putAllForCreate(Map<? extends K, ? extends V> m)。init方法是一個空方法，里面沒有任何內容。putAllForCreate看方法名就是創建的時候將傳入的map全部放入新創建的對象中。該方法中還涉及到其他方法，將在后面介紹。

    先看初始化table時均使用了Entry，這是HashMap的一個內部類，實現了Map接口的內部接口Entry。

    下面給出Map.Entry接口及HashMap.Entry類的內容。

    Map.Entry接口定義的方法

K getKey();//獲取Key
V getValue();//獲取Value
V setValue();//設置Value，至於具體返回什么要看具體實現
boolean equals(Object o);//定義equals方法用於判斷兩個Entry是否相同
int hashCode();//定義獲取hashCode的方法

    HashMap.Entry類的具體實現

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//對下一個節點的引用（看到鏈表的內容，結合定義的Entry數組，是不是想到了哈希表的拉鏈法實現？！）
        final int hash;//哈希值

        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
        V oldValue = value;
            value = newValue;
            return oldValue;//返回的是之前的Value
        }

        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))//先判斷類型是否一致
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
// Key相等且Value相等則兩個Entry相等
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }
        // hashCode是Key的hashCode和Value的hashCode的異或的結果
        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }
        // 重寫toString方法，是輸出更清晰
        public final String toString() {
            return getKey() + "=" + getValue();
        }

        /**
         *當調用put(k,v)方法存入鍵值對時，如果k已經存在，則該方法被調用（為什么沒有內容？）
         */
        void recordAccess(HashMap<K,V> m) {
        }

        /**
         * 當Entry被從HashMap中移除時被調用（為什么沒有內容？）
         */
        void recordRemoval(HashMap<K,V> m) {
        }
    }

    看完屬性和構造方法，接着看HashMap中的其他方法，一個個分析，從最常用的put和get說起吧。

    put()

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

    當存入的key是null的時候將調用putForNUllKey方法，暫時將這段邏輯放一邊，看key不為null的情況。先調用了hash(int h)方法獲取了一個hash值。

static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    這個方法的主要作用是防止質量較差的哈希函數帶來過多的沖突（碰撞）問題。Java中int值占4個字節，即32位。根據這32位值進行移位、異或運算得到一個值。

static int indexFor(int h, int length) {
        return h & (length-1);
    }

    indexFor返回hash值和table數組長度減1的與運算結果。為什么使用的是length-1？應為這樣可以保證結果的最大值是length-1，不會產生數組越界問題。

    獲取索引位置之后做了什么？探測table[i]所在的鏈表，所發現key值與傳入的key值相同的對象，則替換並返回oldValue。若找不到，則通過addEntry(hash,key,value,i)添加新的對象。來看addEntry(hash,key,value,i)方法。

void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }

    這就是在一個鏈表頭部插入一個節點的過程。獲取table[i]的對象e，將table[i]的對象修改為新增對象，讓新增對象的next指向e。之后判斷size是否到達了需要擴充table數組容量的界限並讓size自增1，如果達到了則調用resize(int capacity)方法將數組容量拓展為原來的兩倍。

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        // 這個if塊表明，如果容量已經到達允許的最大值，即MAXIMUN_CAPACITY，則不再拓展容量，而將裝載拓展的界限值設為計算機允許的最大值。
        // 不會再觸發resize方法，而是不斷的向map中添加內容，即table數組中的鏈表可以不斷變長，但數組長度不再改變
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        // 創建新數組，容量為指定的容量
        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        // 設置下一次需要調整數組大小的界限
        threshold = (int)(newCapacity * loadFactor);
    }

    結合上面給出的注釋，調整數組容量的內容僅剩下將原table中的內容復制到newTable中並將newTable返回給原table。即上面代碼中的“transfer(newTable);table = newTable;”。來看transfer(Entry[] newTable)方法。

void transfer(Entry[] newTable) {
        // 保留原數組的引用到src中，
        Entry[] src = table;
        // 新容量使新數組的長度
        int newCapacity = newTable.length;
// 遍歷原數組
        for (int j = 0; j < src.length; j++) {
            // 獲取元素e
            Entry<K,V> e = src[j];
            if (e != null) {
                // 將原數組中的元素置為null
                src[j] = null;
                // 遍歷原數組中j位置指向的鏈表
                do {
                    Entry<K,V> next = e.next;
                    // 根據新的容量計算e在新數組中的位置
                    int i = indexFor(e.hash, newCapacity);
                    // 將e插入到newTable[i]指向的鏈表的頭部
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

    從上面的代碼可以看出，HashMap之所以不能保持元素的順序有以下幾點原因：第一，插入元素的時候對元素進行哈希處理，不同元素分配到table的不同位置；第二，容量拓展的時候又進行了hash處理；第三，復制原表內容的時候鏈表被倒置。

    一個put方法帶出了這么多內容，接着看看putAll吧。

public void putAll(Map<? extends K, ? extends V> m) {
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;
        // 為什么判斷條件是numKeysToBeAdded，不是(numKeysToBeAdded+table.length)>threshold???
        if (numKeysToBeAdded > threshold) {
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;
            if (newCapacity > table.length)
                resize(newCapacity);
        }

        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            put(e.getKey(), e.getValue());
        }
    }

    先回答上面的問題：為什么判斷條件是numKeysToBeAdded，不是(numKeysToBeAdded+table.length)>threshold???

    這是一種保守的做法，明顯地，我們應該在(numKeysToBeAdded+table.length)>threshold的時候去拓展容量，但是考慮到將被添加的元素可能會有Key與原本存在的Key相同的情況，所以采用保守的做法，避免拓展到過大的容量。

    接着是遍歷m中的內容，然后調用put方法將元素添加到table數組中。

    遍歷的時候涉及到了entrySet方法，這個方法定義在Map接口中，HashMap中也有實現，后面會解釋HashMap的這個方法，其它Map的實現暫不解釋。

    下面介紹在put方法中被調用到的putForNullKey方法。

private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

    這是一個私有方法，在put方法中被調用。它首先遍歷table數組，如果找到key為null的元素，則替換元素值並返回oldValue；否則通過addEntry方法添加元素，之后返回null。

    還記得上面構造方法中調用到的putAllForCreate嗎？一口氣將put操作的方法看完吧。

private void putAllForCreate(Map<? extends K, ? extends V> m) {
        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            putForCreate(e.getKey(), e.getValue());
        }
    }

    先將遍歷的過程放在一邊，因為它同樣涉及到了entrySet()方法。剩下的代碼很簡單，只是調用putForCreate方法逐個元素加入。

private void putForCreate(K key, V value) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                e.value = value;
                return;
            }
        }
        createEntry(hash, key, value, i);
    }

    該方法先計算需要添加的元素的hash值和在table數組中的索引i。接着遍歷table[i]的鏈表，若有元素的key值與傳入key值相等，則替換value，結束方法。若不存在key值相同的元素，則調用createEntry創建並添加元素。

void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        size++;
    }

    這個方法的內容就不解釋了，上面都解釋過。

    至此所有put相關操作都解釋完畢了。put之外，另一個常用的操作就是get，下面就來看get方法。

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

    該方法分為key為null和不為null兩塊。先看不為null的情況。先獲取key的hash值，之后通過hash值及table.length獲取key對應的table數組的索引，遍歷索引的鏈表，所找到key相同的元素，則返回元素的value，否者返回null。不為null的情況調用了getForNullKey()方法。

private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

    這是一個私有方法，只在get中被調用。該方法判斷table[0]中的鏈表是否包含key為null的元素，包含則返回value，不包含則返回null。為什么是遍歷table[0]的鏈表？因為key為null的時候獲得的hash值都是0。

    添加（put）和獲取（get）都結束了，接着看如何判斷一個元素是否存在。

    HashMap沒有提供判斷元素是否存在的方法，只提供了判斷Key是否存在及Value是否存在的方法，分別是containsKey(Object key)、containsValue(Object value)。

    containsKey(Object key)方法很簡單，只是判斷getEntry(key)的結果是否為null，是則返回false，否返回true。

public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }
final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

    getEntry(Object key)也沒什么內容，只是根據key對應的hash值計算在table數組中的索引位置，然后遍歷該鏈表判斷是否存在相同的key值。

public boolean containsValue(Object value) {
    if (value == null)
            return containsNullValue();

    Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (value.equals(e.value))
                    return true;
    return false;
    }
private boolean containsNullValue() {
    Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (e.value == null)
                    return true;
    return false;
    }

    判斷一個value是否存在比判斷key是否存在還要簡單，就是遍歷所有元素判斷是否有相等的值。這里分為兩種情況處理，value為null何不為null的情況，但內容差不多，只是判斷相等的方式不同。

    這個判斷是否存在必須遍歷所有元素，是一個雙重循環的過程，因此是比較耗時的操作。

    接着看HashMap中“刪除”相關的操作，有remove(Object key)和clear()兩個方法。

    remove(Object key)

public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

    看這個方法，removeEntryKey(key)的返回結果應該是被移除的元素，如果不存在這個元素則返回為null。remove方法根據removeEntryKey返回的結果e是否為null返回null或e.value。

    removeEntryForKey(Object key)

final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

    上面的這個過程就是先找到table數組中對應的索引，接着就類似於一般的鏈表的刪除操作，而且是單向鏈表刪除節點，很簡單。在C語言中就是修改指針，這個例子中就是將要刪除節點的前一節點的next指向刪除被刪除節點的next即可。

    clear()

public void clear() {
        modCount++;
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            tab[i] = null;
        size = 0;
    }

    clear()方法刪除HashMap中所有的元素，這里就不用一個個刪除節點了，而是直接將table數組內容都置空，這樣所有的鏈表都已經無法訪問，Java的垃圾回收機制會去處理這些鏈表。table數組置空后修改size為0。

    這里為什么不直接操作table而是通過tab呢？希望有知道的大俠指點一二。

    主要方法看的差不多了，接着看一個上面提到了好幾次但是都擱在一邊沒有分析的方法：entrySet()。 

    entrySet()

public Set<Map.Entry<K,V>> entrySet() {
    return entrySet0();
    }

    private Set<Map.Entry<K,V>> entrySet0() {
        Set<Map.Entry<K,V>> es = entrySet;
        return es != null ? es : (entrySet = new EntrySet());
    }

    為什么會有這樣的方法，只是調用了一下entrySet0，而且entrySet0的名稱看着就很奇怪。再看entrySet0方法中為什么不直接return entrySet!=null?entrySet:(entrySet = new EntrySet)呢？

    上面的疑問還沒解開，但是先看entrySet這個屬性吧，在文章開頭的屬性定義中並沒有給出這個屬性，下面先看一下它的定義：

private transient Set<Map.Entry<K,V>> entrySet = null;

    它是一個內容為Map.Entry<K,V>的Set。看看在哪些地方往里面添加了元素。 

    為什么上面的那句話我要把它標成紅色？因為這是一個陷阱，在看代碼的時候我就陷進去了。

    仔細看EntrySet這個類。

private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
            return newEntryIterator();
        }
        public boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<K,V> e = (Map.Entry<K,V>) o;
            Entry<K,V> candidate = getEntry(e.getKey());
            return candidate != null && candidate.equals(e);
        }
        public boolean remove(Object o) {
            return removeMapping(o) != null;
        }
        public int size() {
            return size;
        }
        public void clear() {
            HashMap.this.clear();
        }
    }

    看到了什么？這個類根本就沒屬性，它只是個代理。因為它內部類，可以訪問外部類的內容，debug的時候能看到的屬性都是繼承或者外部類的屬性，輸出的時候其實也是調用到了父類的toString方法將HashMap中的內容輸出了。

    keySet()

public Set<K> keySet() {
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }

 

    是不是和entrySet0()方法很像！

private final class KeySet extends AbstractSet<K> {
        public Iterator<K> iterator() {
            return newKeyIterator();
        }
        public int size() {
            return size;
        }
        public boolean contains(Object o) {
            return containsKey(o);
        }
        public boolean remove(Object o) {
            return HashMap.this.removeEntryForKey(o) != null;
        }
        public void clear() {
            HashMap.this.clear();
        }
    }

    同樣是個代理類，contains、remove、clear方法都是調用的HashMap的方法。 

 

    values()

public Collection<V> values() {
        Collection<V> vs = values;
        return (vs != null ? vs : (values = new Values()));
    }

    private final class Values extends AbstractCollection<V> {
        public Iterator<V> iterator() {
            return newValueIterator();
        }
        public int size() {
            return size;
        }
        public boolean contains(Object o) {
            return containsValue(o);
        }
        public void clear() {
            HashMap.this.clear();
        }
    }

    values()方法也一樣是代理。只是Values類繼承自AbstractCollention類，而不是AbstractSet。

    還有一個重要的內容沒有進行說明，那就是迭代器。HashMap中的entrySet()、keySet()、values()等方法都使用到了迭代器Iterator的知識。其他集合類也有使用到迭代器，將另寫博文總結討論集合類的迭代器。