HashMap部分源码解析

本文要解决的问题

1.HashMap的结构是怎样的

2.HashMap怎么解决Hash冲突的

要解决以上两个问题 我们只要假设new 一个HashMap 然后把.put()走一遍 就会知道结果了

首先我们看看最基本的一些东西

（1）HashMap的存放单位

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
}

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
}

最开始每个存放单位是一个Node，后来转变成TreeNode，至于什么时候转变到后面再说

（2）HashMap的一些成员常/变量和构造函数

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;transient Node<K,V>[] table;
int threshold;
final float loadFactor;

public HashMap(int initialCapacity, float loadFactor)
public HashMap(int initialCapacity)
public HashMap() 
public HashMap(Map<? extends K, ? extends V> m)

其中threshold代表容量,loadFactor代表负载因子，前三个构造函数的作用就是给它们值，或者让它们是默认的值，后一个暂不考虑

好，到了这里我们可以开始假设new一个HashMap了

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

此时loadFactor=0.75f，threshold等于0

然后我们put()一个键值对进去，跟踪它的代码

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

进入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);

(tab=table)==null,进到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){..........}
        else if (oldThr > 0){............} 
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {................}
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;

oldCap和oldThr,newCap,newThr都为0,进到中间的else给newCap,newThr赋值，然后构造newTab，table=newTab,

此时的table是一个 DEFAULT_INITIAL_CAPACITY = 1 << 4 也就是长16的数组

到此返回putVal()

p = tab[i = (n - 1) & hash]

这一句有点深奥，大概就是通过这个方式知道每个值应该在的位置，此时tab[任意]为null,

tab[i] = newNode(hash, key, value, null);

Node被放进了数组里，目前我们知道了HashMap可能是个数组结构，接下来我们在每次key值不同的情况下继续put(),put(),  但此时的HashMap毕竟是一个16长的数组，最好的情况下数组放满，我们来到第17次put()   

PS：这里有个特别不严谨的地方，我们忽略了扩容，总之要知道会有冲突发生的情况

if (++size > threshold)
            resize();

这时突然发现 p = tab[i = (n - 1) & hash] 不为空了， 我们迎来了第一次的Hash冲突，为了解决冲突，我们进入到else

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

我们看到在else里面有三个if，else if，else的选项

第一个不讨论，因为它是改变已有的值，而我们假设的是放了16个不同key的值

第二个不讨论，因为现在的存放单位是Node，要等到情况三发生多次后才可能发生

第三种情况中，循环中后面的 if和情况一一样是改变已有值，第一个if意思是看Node有没有next结点，没有的话此时在table[x]里的Node的下一个结点就是我们第17次放进去的结点了，

到了这里，目前已知的HashMap的结构变成了数组加链表。

继续往下看，紧跟着有一句

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

当binCount=7,即一条链表上的Node个数等于8时，触发了 treeifyBin()

final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

我想大家猜都能猜到它的意思，没错，它就是把链表变成了一颗红黑树，链表上的Node都变成了TreeNode

到此为止，我们已经很清楚HashMap的结构和怎么解决Hash冲突了

最后再说一下链表和树的转换

static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;

链表个数达到8时，转成树，树的个数降到6时，转成链表，至于为什么选6和8，原因在于链表个数为8时平均查询到的次数为4，树2的3次方=8,3次比4次少了一次，而到6，树和链表的效率也会变得差不多，不选7是为了防止太过于频繁的转换