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