JDK源码之HashMap源码解析

HashMap 源码解析

一：先看一下HashMap的常量

    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;     static final int MAXIMUM_CAPACITY = 1 << 30;    static final float DEFAULT_LOAD_FACTOR = 0.75f;    static final int TREEIFY_THRESHOLD = 8;    static final int UNTREEIFY_THRESHOLD = 6;    static final int MIN_TREEIFY_CAPACITY = 64;

DEFAULT_INITIAL_CAPACITY HashMap 容量变量，默认1 << 4即16，这个参数不能太大，太大遍历HashMap会比较慢，也不能太小，太小很容易导致扩容。
MAXIMUM_CAPACITY HashMap 支持的最大容量，2^30。
DEFAULT_LOAD_FACTOR HashMap 的负载因子，默认为 0.75f，当HashMap 负载率(float)(存储的数据量/容量)大于0.75f,时会触发扩容。
TREEIFY_THRESHOLD: 如果哈希函数不合理，即使扩容也无法减少箱子中链表的长度，因此 Java 的处理方案是当链表太长时，转换成红黑树。这个值表示当某个箱子中，链表长度大于 8 时，有可能会转化成树。
UNTREEIFY_THRESHOLD: 在哈希表扩容时，如果发现链表长度小于 6，则会由树重新退化为链表。
MIN_TREEIFY_CAPACITY: 在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。

二：HashMap的构造函数

public HashMap(int initialCapacity, float loadFactor) {        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal initial capacity: " +                                               initialCapacity);        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " +                                               loadFactor);        this.loadFactor = loadFactor;        this.threshold = tableSizeFor(initialCapacity);    }

这是提供2个参数赋值的构造函数，分别对容量，负载因子进行赋值，容量必须时一个大于0，小于2^30的整数，构造函数调用了tableSizeFor(initialCapacity)，即根据容量计算HashMap下一次需要扩展的容量

/**     * 求出下一次扩容的大小,大于 cap 2 的最小幂     * @param cap 是期望的大小     * @return     */static final int tableSizeFor(int cap) {        int n = cap - 1;        n |= n >>> 1;        n |= n >>> 2;        n |= n >>> 4;        n |= n >>> 8;        n |= n >>> 16;        //如果 n < 0，取 1，否则取 min(MAXIMUM_CAPACITY，n + 1)        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;    }

根据容量值求出下一次期望得容量值，处理的十分巧妙。cap - 1 做了大量得位移以及或操作，为什么要这样做呢，我们知道这样是为了求出大于cap得2的最小幂
从前面我们已经知道，HashMap的最大容量是2^30，我们假设需要的容量的二进制如下所示
cap = 0100101010101010101010101010101，我们可以看出大于cap的2的最小幂应该是111111111111111111111111111111 + 1，现在问题来了，怎么才能得到111111111111111111111111111111呢，需要把cap最高位开始向右扩展成全1，cap与cap左移1位进行或操作，这样是不是cap最高位肯定有2位连续的1的，然后2位扩展成4位，4位扩展成8位，8位扩展成16位，16位扩展成32位，到这里，就结束了，因为HashMap容量最大也就31位。
HashMap还有三个构造函数，这些构造函数传值则取值，否则取默认值

public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted    }public HashMap(Map<? extends K, ? extends V> m) {        this.loadFactor = DEFAULT_LOAD_FACTOR;        putMapEntries(m, false);    }

三：HashMap put函数

/** * 往HashMap塞<key，value>，如果这个HashMap之前有这个key的值，那么这个key的value会被覆盖掉 * 真正put是在putval中进行的，在这之前，对key进行了一次hash求值 * @param key * @param value * @return */public V put(K key, V value) {        return putVal(hash(key), key, value, false, true);    }final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node<K,V>[] tab; Node<K,V> p; int n, i;        if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;        if ((p = tab[i = (n - 1) & hash]) == null)            tab[i] = newNode(hash, key, value, null);        else {            Node<K,V> e; K k;            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k))))                e = p;            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;                }            }            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;    }

真正执行put操作的是putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)，我们先看下put函数做了什么，put对key求hash然后把参数传给putVal函数执行put操作。
HashMap，自然和hash密切相关，先看看hash(key)

  /**     * 计算key的hash值，如果key为null，那么key的hash值为0，也就是说null的hash地址恒为零     * @param key     * @return     */    static final int hash(Object key) {        int h;        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);    }

对key的hashcode进一步进行计算以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀
下面继续看putVal函数

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node<K,V>[] tab; Node<K,V> p; int n, i;        if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;        if ((p = tab[i = (n - 1) & hash]) == null)            tab[i] = newNode(hash, key, value, null);        else {            Node<K,V> e; K k;            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k))))                e = p;            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;                }            }            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;    }

HashMap 的存储结构是Node<K,V>[] tab，其实就是一个数组

if ((p = tab[i = (n - 1) & hash]) == null)            tab[i] = newNode(hash, key, value, null);

如果该key的hash位置不存在，则直接在该hash位置插入一个节点，否则如果key已经存在，则在后面根据是否替换进行相关处理。

if (p instanceof TreeNode)                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

这里是因为HashMap基础数据结构是数组+链表的形式，但是当链表长度到达一定长度时，链表会转化为一棵红黑树，所以这里当该hash位置已经是一棵树时，则在红黑树中插入一个节点，关于树的细节后面再说

如果该hash位置是一个链表时，则在链表尾部插入该节点

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            treeifyBin(tab, hash);

这里可以看到，当链表长度大于TREEIFY_THRESHOLD-1时，会转化为一棵红黑树，关于红黑树的转化后面再说。
最后，putVal函数还有一个小点

if (!onlyIfAbsent || oldValue == null)                    e.value = value;

这里是说，在key存在的且需要替换或者以前的value为null的时候，会更新value。到这里HashMap的插入操作就说完了，知道怎么put就知道怎么get了。
下面这个函数是把普通的Map转HashMap

/**     * 把普通 Map 函数转为 HashMap     * 如果 HashMap 为空，获取 Map 需要的容量，((float)s / loadFactor) + 1.0F 容量 = 总量除以填充率     * 如果 HashMap 不为空，，如果容量小于 Map size，则扩容     * 最后 hash key，value 塞进 HashMap     * @param m     * @param evict     */    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {        int s = m.size();        if (s > 0) {            if (table == null) { // pre-size                float ft = ((float)s / loadFactor) + 1.0F;                int t = ((ft < (float)MAXIMUM_CAPACITY) ?                         (int)ft : MAXIMUM_CAPACITY);                if (t > threshold)                    threshold = tableSizeFor(t);            }            else if (s > threshold)                resize();            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {                K key = e.getKey();                V value = e.getValue();                putVal(hash(key), key, value, false, evict);            }        }    }

下面看一下HashMap的扩容的方法
resize()

final Node<K,V>[] resize() {        Node<K,V>[] oldTab = table;        int oldCap = (oldTab == null) ? 0 : oldTab.length;        int oldThr = threshold;        int newCap, newThr = 0;        if (oldCap > 0) {            if (oldCap >= MAXIMUM_CAPACITY) {                threshold = Integer.MAX_VALUE;                return oldTab;            }            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)                newThr = oldThr << 1; // double threshold        }        else if (oldThr > 0) // initial capacity was placed in threshold            newCap = oldThr;        else {               // zero initial threshold signifies using defaults            newCap = DEFAULT_INITIAL_CAPACITY;            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);        }        if (newThr == 0) {            float ft = (float)newCap * loadFactor;            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?                      (int)ft : Integer.MAX_VALUE);        }        threshold = newThr;        @SuppressWarnings({"rawtypes","unchecked"})            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];        table = newTab;        if (oldTab != null) {            for (int j = 0; j < oldCap; ++j) {                Node<K,V> e;                if ((e = oldTab[j]) != null) {                    oldTab[j] = null;                    if (e.next == null)                        newTab[e.hash & (newCap - 1)] = e;                    else if (e instanceof TreeNode)                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);                    else { // preserve order                        Node<K,V> loHead = null, loTail = null;                        Node<K,V> hiHead = null, hiTail = null;                        Node<K,V> next;                        do {                            next = e.next;                            if ((e.hash & oldCap) == 0) {                                if (loTail == null)                                    loHead = e;                                else                                    loTail.next = e;                                loTail = e;                            }                            else {                                if (hiTail == null)                                    hiHead = e;                                else                                    hiTail.next = e;                                hiTail = e;                            }                        } while ((e = next) != null);                        if (loTail != null) {                            loTail.next = null;                            newTab[j] = loHead;                        }                        if (hiTail != null) {                            hiTail.next = null;                            newTab[j + oldCap] = hiHead;                        }                    }                }            }        }        return newTab;    }

首先判断目前表容量是不是大于最大容量，如果大于等于则不扩容

else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)                newThr = oldThr << 1; // double threshold

从这里看一看出，扩容是double了，右移一位，扩容之后，就要做数据迁移了，因为容量变了，所以数据需要重新hash寻址。