HashMap集合--put（）方法

一、put（）方法源码

public V put(K key, V value) {
		if (table == EMPTY_TABLE) { //是否初始化
            inflateTable(threshold);
        }
        //当key为null，调用putForNullKey方法，保存null与table第一个`        位置中，这是HashMap允许为null的原因
        if (key == null)
            return putForNullKey(value);
        //计算key的hash值
        int hash = hash(key.hashCode());                  ------(1)
        //计算key hash 值在 table 数组中的位置
        int i = indexFor(hash, table.length);             ------(2)
        //从i出开始迭代 e,找到 key 保存的位置
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            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;     //返回旧值
            }
        }
        //修改次数增加1
        modCount++;
        //将key、value添加至i位置处
        addEntry(hash, key, value, i);
        return null;
    }

解析：
1、首先会判断一下table有没有进行一个初始化，如果table没有进行初始化，则对table进行初始化操作。
2、然后会判断一下key是不是为null。如果key为null则会将调用putForNullKey（）方法。putForNullKey（）方法会遍历数组table[0],如果存在key为null的，则会将table[0]赋值，返回旧值，否则进行添加操作。

 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;  
    } 

3、然后根据调用hash（）算法，获取key的hash值。
hash（）方法对h进行右移和异或运算。

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);
    }

4、调用indexFor进行取模操作，即获取key在table中的位置

• &-------->位运算符

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

5、然后去循环table[i],断该条链上是否有hash值相同的(key相同)。若存在相同，则直接覆盖value，返回旧value，若不相同则调用addEntry（）方法，往table[i]里面赋值。

6、addEntry（）方法，首先会判断size是不是超过当前的阈值并且table[index]的位置是不是为null,如果两者都符合则会对集合进行扩容操作，否则调用createEntry()方法

void addEntry(int hash, K key, V value, int bucketIndex) {  
       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);  
   }  

7、resize（）方法
重新new一个数据，并将老的数组里面的值转移到新的数组里面

void resize(int newCapacity) {  
       Entry[] oldTable = table;  
       int oldCapacity = oldTable.length;  
       if (oldCapacity == MAXIMUM_CAPACITY) {  //扩容前的数组大小如果已经达到最大(2^30)了
           threshold = Integer.MAX_VALUE;  修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
           return;  
       }  
  
       Entry[] newTable = new Entry[newCapacity];  
       transfer(newTable, initHashSeedAsNeeded(newCapacity));  
       table = newTable;  
       threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);  
   }  

8、 transfer（）方法。
看图可知看出，transfer（）运用了双层循环，首先遍历老的table，然后遍历数组里面的链表

void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

9、createEntry（）方法

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

10、 Entry

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