JDK1.8源码解析-HashMap

jdk1.8对hashmap进行了优化，1.8之前hashmap的构成是由数组和链表组成的，而jdk1.8则对bucket容器中的元素结构进行了优化，若使用链表则在大量元素进行查找时会降低效率。

我们不妨从它的源码入手，了解jdk1.8对hashmap所作的优化。

---------------------------------------------------------------更新----------------------------------------------------------------

jdk中实现hashmap的哈希函数为index = （n-1）&（hashcode^hascode>>>16)。

jdk中解决hashmap的哈希冲突的办法是链地址法 。

jdk中hashmap的负载因子的作用：判断表空/满的标准。负载因子越大，意味着哈希表越满，越容易导致冲突，性能也就越低。

rehash操作即为重新建一个表，对每个结点的下标通过哈希函数重新计算。

-------------------------------------------------------------------------------------------------------------------------------------

私有属性

/**
 * 默认容量 - 必须是2的幂.
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 16

/**
 * 如果具有参数的任一构造函数隐式指定较高值，则使用最大容量。
 * 1<<30.
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 无特殊指定时默认的加载因子
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

//一个桶的树化阈值
//当桶中元素个数超过这个值时，需要使用红黑树节点替换链表节点
//这个值必须为 8，要不然频繁转换效率也不高
static final int TREEIFY_THRESHOLD = 8;

//一个树的链表还原阈值
//当扩容时，桶中元素个数小于这个值，就会把树形的桶元素 还原（切分）为链表结构
//这个值应该比上面那个小，至少为 6，避免频繁转换
static final int UNTREEIFY_THRESHOLD = 6;

/**
*容器可以树化的最小表容量。 （否则，如果bin中的节点太多，则会调整表的大小。）
*应该至少为4*TREEIFY_THRESHOLD，以避免调整大小和树化阈值之间的冲突。
**/
static final int MIN_TREEIFY_CAPACITY = 64;

 

这里定义了hashmap的默认容量，最大容量与加载因子，这是1.7之中就有的。而为了将bucket中的元素根据其个数调整其结构，当达到一定值时会将链表变为红黑树，而当其小于一定值时又回将红黑树变为链表，但是这里要注意的是我们注意树化bucket的阈值不应该大于（或者说要远小于）rehash时的阈值。

 /**
     * 
     *该表在首次使用时初始化，并根据需要调整大小。 分配时，长度始终是2的幂。 
     *（我们还在一些操作中容忍长度为零，以允许当前不需要的自举机制。）
     */
    transient Node<K,V>[] table;

    /**
     *保持缓存的entrySet（）。 请注意，AbstractMap字段用于keySet（）和values（）。
     */
    transient Set<Map.Entry<K,V>> entrySet;

    /**
     * 此map中包含的键 - 值映射的数量。
     */
    transient int size;

    /**
     *此HashMap已被结构修改的次数。
     *结构修改是那些改变HashMap中映射数量或以其他方式修改其内部结构（例如，重新散列）的修改。 
     *该字段用于使HashMap的Collection-views上的迭代器失败。 （请参阅ConcurrentModificationException）。
     */
    transient int modCount;

    /**
     *要调整大小的下一个大小值（capacity * load factor）。
     *
     * @serial
     */
    // (The javadoc description is true upon serialization.
    // Additionally, if the table array has not been allocated, this
    // field holds the initial array capacity, or zero signifying
    // DEFAULT_INITIAL_CAPACITY.)
    int threshold;

    /**
     * 哈希表的加载因子。
     *
     * @serial
     */
    final float loadFactor;

以上定义了哈希表结构是由node组成的数组，并定义了大小、加载因子和用于快速失败的modcount。下面我们来看看node的结构吧。

node中既作为treenode的父类，而且在创建linkedhashmap时的结点也用此做父类。

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;//hash值
    final K key;//键值
    V value;//值
    Node<K,V> next;//下一个结点

    Node(int hash, K key, V value, Node<K,V> next) {//构造函数
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey()        { return key; }//获取键
    public final V getValue()      { return value; }//获取值
    public final String toString() { return key + "=" + value; }

    public final int hashCode() {//重写hashcode方法，键值对象的异或作为hash值
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {//设置值
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {//重写equal方法
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {//判断类型
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

这里注意重写后的hashcode方法和equals方法，node的hashcode是通过键的hash与值的hash异或得到的。所以这里就造成了即使两个node的hash相同，他们的键与值也不一定相等。所以要通过equals方法重新对两个对象进行判断。

私有方法

    //获取键的hash值
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

计算hash时，高16bit不变，低16bit和高16bit做了一个异或。这是因为，table的长度都是2的幂，因此数组下标index（index = （n-1） & hash;n为node数组的长度，index为元素下标）仅与hash值的低n位有关，hash值的高位都被与操作置为0了。而数组的最大长度为（65536），所以hashcode在哈希函数中只有16位被用到，为提高利用率，通过高16位与低16位异或进行运算。

原注释为： 因为该表使用2次幂掩蔽，所以仅在当前掩码之上的位中变化的散列组将始终发生冲突。 （在已知的例子中是在小表中保存连续整数的浮点键集。）因此我们应用一个向下扩展高位比特影响的变换。 在速度，效用和比特扩展质量之间存在权衡。 因为许多常见的哈希集合已经合理分布（因此不会受益于传播），并且因为我们使用树来处理容器中的大量冲突，所以我们只是以最便宜的方式对一些移位的位进行异或，以减少系统损失， 以及由于表格边界而包含最高位的影响，否则这些位将永远不会用于索引计算。

举个栗子，设表长为8，entry a的hashcode为10000111，则其树组下标为7，若entry b的hashcode为11000111，则其数组下标也为7，若用高4位与低4位进行异或，则a的下标为0，b的下标为4，这样运算后，entry的分布更均匀。

常用方法

常用的方法里总是会对bucket中的node或者treenode进行操作，对treenode的操作可以查看：JDK1.8源码解析-HashMap.TreeNode

get（key）

获取结点，通过哈希函数获取键的hash，然后进行查找。

  /**
     * 根据键或取map中的值
     */
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    /**
     * 实现map.get方法
     */
    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) {//哈希表不为空
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))//若为bucket首节点
                return first;
            if ((e = first.next) != null) {//
                if (first instanceof TreeNode)//bucket为红黑树
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);//查找树节点
                do {//bucket进行链表查找
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

put（）

插入结点时要注意bucket是否为空，bucket的结构是链表还是树结构，插入后bucket容量是否会超过阈值，若超过则要将bucket由链表转换为红黑树。putVal中onlyIfAbsent为true时表示不会修改已经存在的映射关系。而evict为true时表示表处于创建模式（主要用在linkedHashMap中，在hashmap中不起作用）。

 /**
     * 将指定的值与此映射中的指定键相关联。 如果映射先前包含键的映射，则替换旧值。
     *
     *
     */
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    /**
     * 实现put方法
     *
     */
    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)//若bucket为红黑树
                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) //若bucket容量到阈值
                            treeifyBin(tab, hash);//将bucket进行树化
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { //键已经存在映射
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)//若大小超出负载容量
            resize();//重新调整hashmap的大小
        afterNodeInsertion(evict);
        return null;
    }

resize（）--rehash

当插入元素后若超出负载容量（我们不可能将哈希表填满，这样会影响查询速度），所以在达到负载容量后要重新扩容，并为结点重新计算hash值。

/**
     * 初始化或加倍表格大小。 如果为null，则根据字段阈值中保存的初始容量目标进行分配。 
     * 否则，因为我们正在使用二次幂扩展，所以每个bin中的元素必须保持相同的索引，或者在新表中以两
     *个偏移的幂移动。
     *
     * @return the table
     */
    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) {//若旧表容量大于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 {               // 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) {//旧表不为空，进行rehash操作，为每个结点重新计算hash
            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 { //若为链表
                        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;
    }

扩容时，将旧哈希表中的结点复制到新的哈希表中并将其返回。

remove（）

删除哈希表中的结点

 /**
     * 从此映射中删除指定键的映射（如果存在）。
     *
     */
    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

    /**
     * 实现删除方法
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to match if matchValue, else ignored
     * @param matchValue 若为true则只在值相等时删除
     * @param movable 若为false，则在其他节点删除时不能删除
     * @return the node, or null if none
     */
    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {//查找结点
            Node<K,V> node = null, e; K k; V v;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);//删除结点
                else if (node == p)
                    tab[index] = node.next;//删除节点
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

可以看到删除操作上没有什么新意，查找结点的那一部分与get（）方法同，而删除结点在树和链表中又有各自的操作。所以不难理解。