HashMap源码分析

一.简述：

HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。

HashMap由于所有方法都没有加锁，所以效率高但是线程不安全。

二.HashMap所使用到的数据结构：

table是一个哈希表用来进行地址映射,里面存的是一个链表的头结点，可以以最快的时间来获取所要查找的元素，在不发生散列冲突的情况下，理想状态查找的时间复杂度为O(1).

当发生散列冲突时， 就将元素存放在对应冲突的哈希表的头结点的链表后面，这个链表是一个单链表。

当一个桶上的结点数大于等于8的时候，会将这条链表转化为一个红黑树来进行数据存贮，这样的目的是减少散列冲突的时候所带来查询时间的增加。当桶上元素小于等于6时，红黑树又会转化成一条链表。

三.源码解析

//先来看一下关键字段 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//默认的初始容量，aka 16 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;//哈希数组，用来进行下标索引查找元素 transient int size//此HashMap中所有元素的个数

回忆一下之前咱们学习链表时是怎么学的，先得有一个链表，然后根据链表如何来增加数据来决定这个链表的其他方法，那咱们来类比学习的来看一下HashMap的put方法

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

HashMap的put方法是将所要存入的键值对以及键的哈希值传入putVal方法这里的hash()函数是为了减少出现同样的hash值的情况，进而减少散列碰撞。

    static final int hash(Object key) {        int h;        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);    }

一个int型变量占4个字节，一个字节是8位，所以一个int型变量占32位，hash算法的处理机制是将一个键的hashcode的值与他的hashcode右移16位之后的值进行异或运算，高位的信息得以保存，地位的信息中掺杂了高位的信息，这样可以使得出来的数的随机性更大，更不容易散列冲突。

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)//当第一次放入元素时，由于整个hash表还没初始化，所以先调用resize()方法来进行初始化这个哈希表            n = (tab = resize()).length;        if ((p = tab[i = (n - 1) & hash]) == null)//在未发生散列碰撞的情况下，哈希表下标为(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))))//当是同一个桶且key是同一个key的时候，将此节点赋给e，e就不为空了                e = p;            else if (p instanceof TreeNode)                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//此处先判断此节点是不是树的节点，如果是树的节点的话就进行putTreeVal操作，当这个key是在同一颗树里面且键值一样的话，就返回这个节点，如果是新增节点的话就返回null。            else {                for (int binCount = 0; ; ++binCount) {//因为之前已判断过是否为树节点，所以此处必然是链表的节点                    if ((e = p.next) == null) {//当节点为null的时候，新增一个节点，并且当这个桶上节点个数大于等于8的时候，将此链表转换为一颗红黑树。                        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))))//当此键存在于这个桶中时，就跳出循环，此时的e不为null                        break;                    p = e;                }            }            if (e != null) { // 这个操作就是在上面找到了存有对应key的那个节点，在这里只需要将原来的值替换为新的值就行，无需进行增加节点的操作并结束函数                V oldValue = e.value;                if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e);                return oldValue;            }        }        ++modCount;        if (++size > threshold)//只有当新增节点的时候才会执行此操作，threshold为此哈希表长度的两倍，当桶上所有的节点都总数大于这个数的时候，就证明此hashmap极易发生散列碰撞。此时就要对此哈希表进行扩容。            resize();        afterNodeInsertion(evict);        return null;    }

 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; //新的临界值也扩为之前的两倍。         }        else if (oldThr > 0) // 之前临界值存在，就直接把老的临界值作为新表的大小            newCap = oldThr;        else {               //当哈希表不存在的时候，初始化这个哈希表的大小            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) {//将一条链表桶上的元素分为e.hash & oldCap等于0与非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;    }

看到这里，HashMap的put方法就算是看完了，主要是利用hash算法算出的哈希值，在经过(n - 1) & hash过程算出一个位置下标，其目的是减少散列冲突，当发生散列冲突时，就将对应的元素放于链表上，当链表的长度大于等于8的时候就将这个链表转化为一棵树，当树的节点小于等于6的时候，就将这个树转化为链表，这样的操作是为了减少查找时的时间复杂度。

然后我们在来看一下HashMap的get()方法

    public V get(Object key) {        Node<K,V> e;        return (e = getNode(hash(key), key)) == null ? null : e.value;    }

通过键的hash值和键的内容查找元素

final Node<K,V> getNode(int hash, Object key) {        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;        if ((tab = table) != null && (n = tab.length) > 0 &&            (first = tab[(n - 1) & hash]) != null) {//先通过(n - 1) & hash过程算出对应hash值在哈希表中的下标，先确定他存不存在            if (first.hash == hash && // 当第一个节点是目标节点的时候直接返回第一个节点                ((k = first.key) == key || (key != null && key.equals(k))))                return first;            if ((e = first.next) != null) {//当第一个节点不是的时候向下查询，当哈希值和键的内容都一致时，就能确定一个节点。                if (first instanceof TreeNode)                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);                do {                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                        return e;                } while ((e = e.next) != null);            }        }        return null;    }

查找时第一次先利用哈希值确定位于哈希数组中的下标，在不发生散列碰撞的情况下，直接就可以找到元素，发生散列碰撞时，就需要在进行遍历桶的操作来查找元素，时间复杂度会大大降低。

然后我们再来看下remove()方法

public V remove(Object key) {        Node<K,V> e;        return (e = removeNode(hash(key), key, null, false, true)) == null ?            null : e.value;    }

这个remove()方法咱们就不细分析了，做的其实是和上面基本上一样的操作，先找到对应节点，然后将这个节点由对应桶上移除。