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

/**
    * Associates the specified value with the specified key in this map.
    * If the map previously contained a mapping for the key, the old
    * value is replaced.
    *
    * @param key key with which the specified value is to be associated
    * @param value value to be associated with the specified key
    * @return the previous value associated with key, or null if there was no mapping for key.
    *  Note that a null return can also indicate that the map previously associated null with key.
    */
public V put(K key, V value) {
    //当key为null时，调用putForNullKey方法，并将该键值对保存到table的第一个位置
    if (key == null)
        return putForNullKey(value);
    //根据key的hashCode计算hash值
    int hash = hash(key.hashCode());             //  ------- (1)
    //计算该键值对在数组中的存储位置（哪个桶）
    int i = indexFor(hash, table.length);              // ------- (2)
    //在table的第i个桶上进行迭代，寻找 key 保存的位置
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {      // ------- (3)
        Object k;
        //判断该条链上是否存在hash值相同且key值相等的映射，若存在，则直接覆盖 value，并返回旧value
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;    // 返回旧值
        }
    }
    modCount++; //修改次数增加1，快速失败机制
    //原HashMap中无该映射，将该添加至该链的链头
    addEntry(hash, key, value, i);
    return null;
}Copy to clipboardErrorCopied

    /**
     * Offloaded version of put for null keys
     */
    private V putForNullKey(V value) {
        // 若key==null，则将其放入table的第一个桶，即 table[0]
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {   // 若已经存在key为null的键，则替换其值，并返回旧值
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;        // 快速失败
        addEntry(0, null, value, 0);       // 否则，将其添加到 table[0] 的桶中
        return null;
    }Copy to clipboardErrorCopied

    /**
     * Applies a supplemental hash function to a given hashCode, which
     * defends against poor quality hash functions.  This is critical
     * because HashMap uses power-of-two length hash tables, that
     * otherwise encounter collisions for hashCodes that do not differ
     * in lower bits.
     *
     * Note: Null keys always map to hash 0, thus index 0.
     */
    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);
    }Copy to clipboardErrorCopied

/**
* Returns index for hash code h.
*/
static int indexFor(int h, int length) {
    return h & (length-1);  // 作用等价于取模运算，但这种方式效率更高
}Copy to clipboardErrorCopied

/**
* Adds a new entry with the specified key, value and hash code to
* the specified bucket.  It is the responsibility of this
* method to resize the table if appropriate.
*
* Subclass overrides this to alter the behavior of put method.
*
* 永远都是在链表的表头添加新元素
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
    //获取bucketIndex处的链表
    Entry<K,V> e = table[bucketIndex];
    //将新创建的 Entry 链入 bucketIndex处的链表的表头
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    //若HashMap中元素的个数超过极限值 threshold，则容量扩大两倍
    if (size++ >= threshold)
        resize(2 * table.length);
}Copy to clipboardErrorCopied

     /**
     * Rehashes the contents of this map into a new array with a
     * larger capacity.  This method is called automatically when the
     * number of keys in this map reaches its threshold.
     *
     * If current capacity is MAXIMUM_CAPACITY, this method does not
     * resize the map, but sets threshold to Integer.MAX_VALUE.
     * This has the effect of preventing future calls.
     *
     * @param newCapacity the new capacity, MUST be a power of two;
     *        must be greater than current capacity unless current
     *        capacity is MAXIMUM_CAPACITY (in which case value
     *        is irrelevant).
     */
    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        // 若 oldCapacity 已达到最大值，直接将 threshold 设为 Integer.MAX_VALUE
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;             // 直接返回
        }
        // 否则，创建一个更大的数组
        Entry[] newTable = new Entry[newCapacity];
        //将每条Entry重新哈希到新的数组中
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);  // 重新设定 threshold
    }Copy to clipboardErrorCopied

/**
* Transfers all entries from current table to newTable.
*/
void transfer(Entry[] newTable) {
    // 将原数组 table 赋给数组 src
    Entry[] src = table;
    int newCapacity = newTable.length;
    // 将数组 src 中的每条链重新添加到 newTable 中
    for (int j = 0; j < src.length; j++) {
        Entry<K,V> e = src[j];
        if (e != null) {
            src[j] = null;   // src 回收
            // 将每条链的每个元素依次添加到 newTable 中相应的桶中
            do {
                Entry<K,V> next = e.next;
                // e.hash指的是 hash(key.hashCode())的返回值;
                // 计算在newTable中的位置，注意原来在同一条子链上的元素可能被分配到不同的子链
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            } while (e != null);
        }
    }
}Copy to clipboardErrorCopied

/**
* Returns the value to which the specified key is mapped,
* or {@code null} if this map contains no mapping for the key.
*
* <p>More formally, if this map contains a mapping from a key
* {@code k} to a value {@code v} such that {@code (key==null ? k==null
* key.equals(k))}, then this method returns {@code v}; otherwise
* it returns {@code null}.  (There can be at most one such mapping.)
*
* <p>A return value of {@code null} does not <i>necessarily</i>
* indicate that the map contains no mapping for the key; it's also
* possible that the map explicitly maps the key to {@code null}.
* The {@link #containsKey containsKey} operation may be used to
* distinguish these two cases.
*
* @see #put(Object, Object)
*/
public V get(Object key) {
    // 若为null，调用getForNullKey方法返回相对应的value
    if (key == null)
        // 从table的第一个桶中寻找 key 为 null 的映射；若不存在，直接返回null
        return getForNullKey();
    // 根据该 key 的 hashCode 值计算它的 hash 码
    int hash = hash(key.hashCode());
    // 找出 table 数组中对应的桶
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
            e != null;
            e = e.next) {
        Object k;
        //若搜索的key与查找的key相同，则返回相对应的value
        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
            return e.value;
    }
    return null;
}Copy to clipboardErrorCopied

 /**
     * Offloaded version of get() to look up null keys.  Null keys map
     * to index 0.  This null case is split out into separate methods
     * for the sake of performance in the two most commonly used
     * operations (get and put), but incorporated with conditionals in
     * others.
     */
    private V getForNullKey() {
        // 键为NULL的键值对若存在，则必定在第一个桶中
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        // 键为NULL的键值对若不存在，则直接返回 null
        return null;
    }Copy to clipboardErrorCopied

• 该 key 对应的值就是 null;
• HashMap 中不存在该 key。

/**
* Constructs an empty HashMap with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
    //负载因子:用于衡量的是一个哈希表的空间的使用程度
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    //HashMap进行扩容的阈值，它的值等于 HashMap 的容量乘以负载因子
    threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
    // HashMap的底层实现仍是数组，只是数组的每一项都是一条链
    table = new Entry[DEFAULT_INITIAL_CAPACITY];
    init();
}Copy to clipboardErrorCopied

static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;     // 键值对的键
    V value;        // 键值对的值
    Entry<K,V> next;    // 下一个节点
    final int hash;     // hash(key.hashCode())方法的返回值
    /**
     * Creates new entry.
     */
    Entry(int h, K k, V v, Entry<K,V> n) {     // Entry 的构造函数
        value = v;
        next = n;
        key = k;
        hash = h;
    }
    ......
}Copy to clipboardErrorCopied

// Constructs an empty HashMap with the specified initial capacity and the default load factor (0.75)
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);  // 直接调用上述构造函数
}Copy to clipboardErrorCopied

/**
* Constructs an empty HashMap with the specified initial capacity and load factor.
*/
public HashMap(int initialCapacity, float loadFactor) {
    //初始容量不能小于 0
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
    //初始容量不能超过 2^30
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    //负载因子不能小于 0
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                            loadFactor);
    // HashMap 的容量必须是2的幂次方，超过 initialCapacity 的最小 2^n
    int capacity = 1;
    while (capacity < initialCapacity)
        capacity <<= 1;
    //负载因子
    this.loadFactor = loadFactor;
    //设置HashMap的容量极限，当HashMap的容量达到该极限时就会进行自动扩容操作
    threshold = (int)(capacity * loadFactor);
    // HashMap的底层实现仍是数组，只是数组的每一项都是一条链
    table = new Entry[capacity];
    init();
}Copy to clipboardErrorCopied

// Constructs a new HashMap with the same mappings as the specified Map.
// The HashMap is created with default load factor (0.75) and an initial capacity
// sufficient to hold the mappings in the specified Map.
public HashMap(Map<? extends K, ? extends V> m) {
    // 初始容量不小于 16
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                    DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
    putAllForCreate(m);
}Copy to clipboardErrorCopied

// HashMap 的容量必须是2的幂次方，超过 initialCapacity 的最小 2^n
int capacity = 1;
while (capacity < initialCapacity)
    capacity <<= 1;Copy to clipboardErrorCopied

• 使用 hash() 方法用于对 Key 的 hashCode 进行重新计算，以防止质量低下的 hashCode()函数实现。由于 hashMap 的支撑数组长度总是 2 的倍数，通过右移可以使低位的数据尽量的不同，从而使 Key 的 hash 值的分布尽量均匀；
• 使用 indexFor() 方法进行取余运算，以使 Entry 对象的插入位置尽量分布均匀。

• 不同的 hash 值发生碰撞的概率比较小，这样就会使得数据在 table 数组中分布较均匀，空间利用率较高，查询速度也较快；
• h&(length - 1) 就相当于对 length 取模，而且在速度、效率上比直接取模要快得多，即二者是等价不等效的，这是 HashMap 在速度和效率上的一个优化。