上文我們講了HashMap那騷騷的邏輯結構，這一篇我們來吹吹它的實現思想，也就是算法層面。有興趣看下或者回顧上一篇HashMap邏輯層面的，可以看下HashMap源碼解析（一）。
使用了哈希表得“拉鏈法”.

我打算按這個順序來講HashMap：幾個關鍵屬性 -> 構造方法-> 存取元素方法 ->解決hash沖突方法->HashMap擴容問題。

4個關鍵屬性：

  /**
     *HashMap的存儲大小
     */
    transient int size;

    /**
     * HashMap的大小臨界值，如果達到這個值就需要重新分配大小
     
 
*/
    int threshold;

    /**
     * 負載因子(默認值一般是0.75)，哈希表在其容量自動增加之前可以達到多滿的一種尺度。
     *當哈希表中的條目數超出了 負載因子與當前容量的乘積時，
     *則要對該哈希表進行 rehash 操作（即重建內部數據結構），從而哈希表將具有大約兩倍的桶數。
     *負載因子過高雖然減少了空間開銷，但同時也增加了查詢成本
     *    static final float DEFAULT_LOAD_FACTOR = 0.75f;
     * @serial
     */
    final float loadFactor;

    
 
/**
     * HashMap修改總數（修改數+刪除數）
     */
    transient int modCount;

構造方法 ：

   /**對四個構造函數的簡單描述 **/
    
    // 默認構造函數
    public HashMap();

    // 指定“容量大小”的構造函數
    public HashMap(int initialCapacity);

    //  指定“容量大小”和“負載因子’‘的構造函數
    public HashMap(int initialCapacity, float loadFactor) ;

    // 包含”子Map的構造函數’
 

    public HashMap(Map<? extends K, ? extends V> m);

詳細描述：

  *默認構造 
     *使用默認負載因子DEFAULT_LOAD_FACTOR（0.75）以及
     *默認容量大小  DEFAULT_INITIAL_CAPACITY
     */
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
    
    /**
     *指定負載因子以及容量大小構造函數（前三個構造函數以這個構造函數為核心對‘容量大小’和‘負載因子’進行不同的賦值，來達到不同構造函數的效果)
     * @param  initialCapacity the initial capacity 容量大小
     * @param  loadFactor      the load factor 負載因子值
     * @throws IllegalArgumentException if the initial capacity is negative
     * or the load factor is nonpositive
     */
    public HashMap(int initialCapacity, float loadFactor) {
        // 容量大小不能小於0 
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        //HashMap最大容量不能超過MAXIMUM_CAPACITY
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        init();
    }


    /** 包含子Map的構造函數
     * 主要對通過對子Map的容量大小的處理給本HashMap的容量大小賦值
     *以及clone子Map給本HashMap
     */
    public HashMap(Map<? extends K, ? extends V> m) {

        //子Map的條目數/負載因子+1會大致等於子 Map的容量大小，通過比較當前子Map的容量大小和
        //默認容易大小對比，找出最大的那個作為該HashMap的容量大小
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);

        //不讓容量大小超過MAXIMUM_CAPACITY ，讓容量大小一直保持為2的冪次方
        inflateTable(threshold);
        
        //將子Map的元素全部添加到本HashMap中。
        putAllForCreate(m);
    }

HashMap的存取方法：

　　既然是線性數組，為什麽能隨機存取？這裏HashMap用了一個小算法，大致是這樣實現：

　　// 存儲時:
　　int hash = key.hashCode(); // 這個hashCode方法這裏不詳述,只要理解每個key的hash是一個固定的int值
　　int index = hash % Entry[].length;
　　Entry[index] = value;

　　// 取值時:
　　int hash = key.hashCode();
　　int index = hash % Entry[].length;
　　return Entry[index];

一些工具方法的解析：

  /**
     *計算hash值
     */
    final int hash(Object k) {
        //hashSeed表示一個與當前實例關聯並且可以減少哈希碰撞概率應用於鍵的哈希碼計算的隨機種子。
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        //對h和鍵的哈希碼進行‘異或’並賦值運算
        h ^= k.hashCode();

        //h右移20位 異或 h右移12位  ，下一行同理。運算過程看下圖2
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    /**返回索引值
     * @param  h 通過hash(Object k)方法計算得來的哈希碼
     * @param  length     表示桶的數量（即數組的長度）
     * 
     */
    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        // 將哈希碼和length進行按位與運算
        return h & (length-1);
    }

圖2：

取元素：

//通過key獲取value
public V get(Object key) {
        如果key為null，則返回null鍵的值
        if (key == null)
            return getForNullKey();

        //獲取鍵為key的實體類
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

    /**
     * 根據鍵找到對應的實體類
     * 實現思路：①：通過計算key的hash值，用indexFor(key，table.length)獲取所在數組位置的下標。
     *          ②：通過尋找處於該下標位置鏈表”上查找“鍵值等於key”的元素。
     */
    final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }
      
        //計算key的hash值
        int hash = (key == null) ? 0 : hash(key);
        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;
        }
        //找不到則返回null
        return null;
    }

    /**
     * 獲取null鍵的值
     */
    private V getForNullKey() {
        if (size == 0) {
            return null;
        }
        //null鍵一般在table下標為0的位置
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

存元素：

   /**往HashMap存儲元素
     * 
     * @param key 鍵
     * @param value 值    
     * @return
     *             
     */
    public V put(K key, V value) {
        //防止table的容量為0；
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        
        //如果key為null，則判斷該hashMap的null鍵是否有值，
        //如果有，則將這個新value存入覆蓋老的value，返回老的value
        if (key == null)
            return putForNullKey(value);

        //計算key的哈希值
        int hash = hash(key);

        //通過key的哈希值以及數組的長度計算索引
        int i = indexFor(hash, table.length);

        找到數組此索引下的鏈表，一個一個得找，看有沒有找到鍵值==該key的元素
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //如果有，則用新value覆蓋老的value  oldValue，並返回oldValue;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        //如果沒有，則modCount++，並添加新元素

        modCount++;

        //添加新元素，具體實現思路，看下面該函數得定義
        addEntry(hash, key, value, i);
        return null;
    }

    /**
      * 新增Entry
     */
    void addEntry(int hash, K key, V value, int bucketIndex) {
        //如果size比臨界值大，而且該下標元素不為空，則對HashMap進行擴容，然後新增一個Entry實例
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }

    /**
     * 
     *新增一個Entry實例，並將該實例得next指向原來得table[bucketIndex];
     */
    void createEntry(int hash, K key, V value, int bucketIndex) {
        // 設置“e”為“新Entry的下一個節點”
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

解決hash沖突方法：下面只具體講了拉鏈法，其它有興趣可自行了解~

開放定址法（線性探測再散列，二次探測再散列，偽隨機探測再散列）
再哈希法
鏈地址法 ：就是在沖突的位置上簡歷一個鏈表，然後將沖突的元素插入到鏈表尾端。
建立一個公共溢出區

HashMap擴容：resize方法

  /** 重新調整HashMap中桶的數量
     *
     *通過判斷新容量大小值，
     *如果 oldCapacity 超過Entty數量的最大值，則將Integer.MAX_VALUE賦給臨界值（閥值），
     *直接返回不進行擴容（這樣以後都不會擴容）
     *如果 oldCapacity 不超過Entty數量的最大值，則創建一個新的數組，將數據轉移到新的數組裏
     *並重新修改閥值
     * @param newCapacity the new capacity, 新容量大小值
     */
    void resize(int newCapacity) {
        //引用擴容前的Entry數組  
        Entry[] oldTable = table; 
        int oldCapacity = oldTable.length;
        // 擴容前的數組大小如果已經達到最大(2^30)了 
        if (oldCapacity == MAXIMUM_CAPACITY) {
            //修改閾值為int的最大值(2^31-1)，這樣以後就不會擴容了  
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        //將原有Entry數組的元素拷貝到新的Entry數組裏
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        //HashMap的table屬性引用新的Entry數組  
        table = newTable;
        //修改閾值  
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

    /**
     * 將原有Entry數組的元素拷貝到新的Entry數組裏
     */
    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                //重新計算每個元素在數組中的位置 
                int i = indexFor(e.hash, newCapacity);
                //標記[1]  
                e.next = newTable[i];
                //將元素放在數組上 
                newTable[i] = e;
                ////訪問下一個Entry鏈上的元素  
                e = next;
            }
        }
    }

這是對HashMap的實現思路的基本分析。HashMap能講的太多了。比如*線程，遍歷叠代，紅黑樹*......每一部分都能獨立開篇來講。以後有機會出

以上是本人對HashMap的一點理解，有什麽理解不當歡迎指出~

[java源碼解析]對HashMap源碼的分析（二）