HashMap

位置： package java.util包下；

繼承關係：

HashMap繼承AbstractMap<K,V>

 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

預設初始容量是16；

  static final float DEFAULT_LOAD_FACTOR = 0.75f;

負載因子為0.75

static class Node<K,V> implements Map.Entry<K,V> 

HashMap中內部類，Node類，用來儲存hashMap中的鍵和值和下一個Node物件的引用。

我們主要從get()和put()方法來解析：

⑴put(K key,V value):

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

⑵ putVal(hash(key), key, value, false, true)

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
//建立Node陣列tab，Node節點p, int 變數 p ,i 
        Node<K,V>[] tab; Node<K,V> p; int n, i;
//將Node<K,V>[] table賦值給tab, 如果 table等於null 或者陣列長度為0， 則呼叫Resize()方法，返回一個newTab
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
//長度與hash值做與運算，求出陣列元素的下標，即存放的位置，如果tab[i] == null ,即沒有元素， 則根據hash，key，value新建一個Node,tab[i] = node；
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
//如果該位置有節點，則另行處理
//建立一個節點e
            Node<K,V> e; K k;
//如果p的hash值等於欲想新增的節點，且 p.key等於新增的Key,且 key ！= null ,
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
//則將p節點賦值給e節點，
                e = p;
            else if (p instanceof TreeNode)
//如果p不等於的話，且p屬於 TreeNode 則將新的節點新增到P節點中
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
//遍歷p節點，如果p節點的後續節點不為null，則將新節點設定為p的下一個節點
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
//如果e的hash等於新增的hash, key也相等，則退出
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
//如果不是，則將e賦值給p
                    p = e;
                }
            }
//如果e不為null,則返回e.values
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
//如果table[]陣列大小大於閾值，則重新設定大小，即擴容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
 

總結：HashMap的儲存是基於一個數組table[],陣列中的元素就是Node節點， 現根據hash值和陣列大小的與運算，求出存放Node的下標，如果table[i]為null， 則將新值放在這個位置，如果這個位置有值,則節點的儲存會以連結串列的方式儲存，則會遍歷當先節點，找到當前節點的尾節點，然後將想要放入的值新增到連結串列的尾部。

⑴get(Object key)

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
 

⑵getNode(int hash, Object key)

final Node<K,V> getNode(int hash, Object key) {
//建立變數 tab陣列， Node節點 first, e，  整型 n ,  泛型 K
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//如果table不為null，陣列長度大於0，且查詢物件的key值等於第一個節點且不為null，
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
//如果hash等於第一個節點，且 key也相等，不為null,返回第一個節點
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
//如果第一個節點額下一個節點不為null,
            if ((e = first.next) != null) {
//且屬於TreeNode,則從TreeNode中獲取鍵為key, 雜湊為hash的節點
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//否則，遍歷e連結串列，在連結串列中找到key , hash 符合要求的Node, 找到即返回，
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
//否則返回null
        return null;
    }

總結：

首先是判斷table[]陣列是否為空，如果為null，返回Null，否則，根據hash值計算出在陣列中的下標，得到的是一個連結串列，首先判斷和連結串列頭的hash， key是否相等，如果相等，則返回，否則遍歷連結串列，找出存在於連結串列中的與hash， key相同的節點，將其返回，否則返回空。