HashMap 源码解读

HashMap在JDK1.7和1.8中有了很大的改变，空闲时间对HashMap做了一点点的研究。

HashMap是一种数组和链表结合的数据结构，我们每次new一个HashMap时，都会构造出一个长度为16的Entry数组，每一个Entry都是一个单向链表，

网上找的一张图，具体的hashMap的结构如下

Entry的数据结构如图所示

 static class Entry<K, V> implements java.util.Map.Entry<K, V> {
         final K key;
         V value;
         HashMap.Entry<K, V> next;
         int hash;

         Entry(int arg0, K arg1, V arg2, HashMap.Entry<K, V> arg3) {
             this.value = arg2;
             this.next = arg3;
             this.key = arg1;
             this.hash = arg0;
         }

首先先解读JDK1.7的Put方法

 public V put(K key, V value) {
         if (this.table == EMPTY_TABLE) {
             this.inflateTable(this.threshold);
         }

         if (key == null) {
             return this.putForNullKey(value);
         } else {
             int hashParam = this.hash(key);
             int index = indexFor(hashParam, this.table.length);

             for (HashMap.Entry entry = this.table[index]; entry != null; entry = entry.next) {
                 if (entry.hash == hashParam) {
                     Object object = entry.key;
                     if (entry.key == key || key.equals(object)) {
                         Object arg6 = entry.value;
                         entry.value = value;
                         entry.recordAccess(this);
                         return arg6;
                     }
                 }
             }

             ++this.modCount;
             this.addEntry(hashParam, key, value, index);
             return null;
         }
     }

2-4行:如果table还未初始化，则先进行初始化

6-7行：如果key的值为空，则把把value值放到第一个位置，具体的代码如下

 private V putForNullKey(V value) {
         for (HashMap.Entry entry = this.table[0]; entry != null; entry = entry.next) {
             if (entry.key == null) {
                 Object object = entry.value;
                 entry.value = value;
                 entry.recordAccess(this);
                 return object;
             }
         }

9行：根据重新计算的HashCode，对Entry数组的大小取模得到一个Entry数组的位置。注意HashMap构造函数中，如果你指定HashMap初始数组的大小initialCapacity，如果initialCapacity不是2的N次幂，HashMap会算出大于initialCapacity的最小2的N次幂的值，作为Entry数组的初始化大小

10行：根据上一步的hashcode值，以及数组的长度，确定出该key所处的下标值

12-19行：首先会判断这个数组里面所有的元素是的hash是否一样，如果hash一样，那么再去判断key值是否一样，如果key值也一样，则会覆盖原先key的value

24-26：如果都不一样，则会在当前的数组中，插入一个链表

移除元素

 public V remove(Object oldKey) {
         HashMap.Entry entry = this.removeEntryForKey(oldKey);
         return entry == null ? null : entry.value;
     }

     final HashMap.Entry<K, V> removeEntryForKey(Object oldKey) {
         if (this.size == 0) {
             return null;
         } else {
             int hashCode = oldKey == null ? 0 : this.hash(oldKey);
             int index = indexFor(hashCode, this.table.length);
             HashMap.Entry entry1 = this.table[index];

             HashMap.Entry entry2;
             HashMap.Entry entry3;
             for (entry2 = entry1; entry2 != null; entry2 = entry3) {
                 entry3 = entry2.next;
                 if (entry2.hash == hashCode) {
                     Object arg6 = entry2.key;
                     if (entry2.key == oldKey || oldKey != null && oldKey.equals(arg6)) {
                         ++this.modCount;
                         --this.size;
                         if (entry1 == entry2) {
                             this.table[index] = entry3;
                         } else {
                             entry1.next = entry3;
                         }

                         entry2.recordRemoval(this);
                         return entry2;
                     }
                 }

                 entry1 = entry2;
             }

             return entry2;
         }
     }

移除元素的操作也很简单

7-8行判断元素是否为空,为空直接返回NULL

10-12行 的操作和put一样,获得key的hash值，然后根据hash值和table数组的大小取模，获得值便是key所处于这个数组的下标,当我们确定是哪个entry时，我们就可以进入到entry链表内部

16-27行 链表从头开始向后寻找，直到找到hashcode的值和key的值都一样的，把上一个链表的next指向下一个链表，这样就把当前的节点给剔除了

JDK8

---

//final修饰 方法内联
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //如果table为空，调用resize初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //根据hash获取下标i，如果tab[i]的node为空，调用newNode新建一个node
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            //如果tab[i]的node为不为空，即存在node链表
            Node<K,V> e; K k;
            //先判断第一个Node的key是否相同，是的话结束判断得到e,
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //调用btree的putTreeVal
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //如果以上条件都不满足，那就开始遍历链表
                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;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //map的putval可以看成getAndSet
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }