hashmap详解(基于jdk1.8)

Posted qumasha

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了hashmap详解(基于jdk1.8)相关的知识,希望对你有一定的参考价值。

简介:

在jdk1.8中,hashmap有了较大的优化,底层实现由之前的“数组+链表”改为了“数组+链表+红黑树”。jdk1.8的hashmap的数据结构如图所示,当链表节点较少时仍然以链表形式存在,当链表节点较多时(大于8)会转化为红黑树。

技术图片

重要知识点:

1、文章中头节点指的是table表上索引位置的节点,也就是链表的头结点

2、根节点(root)指的是红黑树最上面的节点,也就是没有父节点的节点

3、红黑树的根节点不一定是索引位置的头结点(链表的头结点),hashmap通过moveRootToFront方法来维持红黑树的根节点就是索引位置的头结点,但是在removeTreeNode方法中,当movable为false时,不会调用moveRootToFront方法,此时红黑树的根节点不一定是索引位置的头结点,该情形发生在hashIterator的remove方法中

4、转为红黑树之后,链表的结构还存在,通过next属性维持,红黑树节点在进行操作时都会维护链表的结构,并不是转化为红黑树节点,链表结构就不存在了

5、在红黑树上,叶子节点也可能有next节点,因为红黑树的结构与链表的结构是互不影响的,不会因为是叶子节点就说该节点已经没有next节点

6、源码中的一些变量的定义为:如果定义了一个节点p,则pl(p left)为p的左节点,pr(p right)为p的右节点,pp(p parent)为p的父节点,ph(p hash)为p的hash值,pk(p key)为p的key值,kc(key class)为key的类等等。

7、链表中移除一个节点只需要如图的操作

技术图片

8、红黑树在维护链表结构时,移除一个节点只需要如图所示操作(红黑树中增加了一个prev属性),其他操作同理。注:此处只是红黑树维护链表结构的操作,红黑树还需要单独进行红黑树的移除或者其他操作

技术图片

9、源码中进行红黑树的查找时,会反复使用两条规则:1)如果目标节点的hash值小与p节点的hash值,则向p节点的左边遍历;否则向p节点的右边遍历。2)如果目标节点的key值小与p节点的key值,则向p节点的左边遍历;否则向p节点的右边遍历。这两条规则是利用了红黑树的特性(左节点<根节点<右节点)

10、源码中进行红黑树的查找时,会用dir(direction)来表示向左还是向右查找,dir存储的值是目标节点的hash/key与p节点的hash/key的比较结果

基本属性:

// 默认容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
 
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;    
 
// 默认负载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f; 
 
// 链表节点转换红黑树节点的阈值, 9个节点转
static final int TREEIFY_THRESHOLD = 8; 
 
// 红黑树节点转换链表节点的阈值, 6个节点转
static final int UNTREEIFY_THRESHOLD = 6;   
 
// 转红黑树时, table的最小长度
static final int MIN_TREEIFY_CAPACITY = 64; 
 
// 链表节点, 继承自Entry
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;
   
    // ...
}

 

定位哈希桶数组索引位置

由于HashMap的数据结构为“数组+链表+红黑树”的组合,所以我们希望这个HashMap里面的元素位置尽量分布地更加均匀,尽量使得每个位置上的元素数量只有一个,那么当我们用hash算法求得这个位置的时候,马上就可以知道对应位置的元素就是我们要的,不用遍历链表/红黑树,大大优化了查询的效率。HashMap定位数组索引的位置,直接决定了hash方法的离散性能。源码为:

// 代码1
static final int hash(Object key) { // 计算key的hash值
    int h;
    // 1.先拿到key的hashCode值; 2.将hashCode的高16位参与运算
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// 代码2
int n = tab.length;
// 将(tab.length - 1) 与 hash值进行&运算
int index = (n - 1) & hash;

1、拿到key的hashCode值

2、将hashCode的高位参与运算,重新计算hash值

3、将计算出来的hash值于(table.length-1)进行&运算

解读:对于任意给定的对象,只要他的hashCode()返回值相同,那么计算得到的hash值总是相同的。把hash值对table长度取模运算,这样一来,元素的分布相对来说是比较均匀的。

但是模运算的消耗比较大,计算机中的位运算比较快,因此使用代码2的位与运算来代替模运算。他通过(table.length-1)&h来获得该对象的索引位置。

在JDK1.8的实现中,还优化了高位运算的算法,将hashCode的高16位与hashCode进行异或运算,主要是为了在table的长度较小的时候,让高位也参与运算,并且不会有太大的开销。

例子:

当table的长度为16时,table.length-1=15,在二进制中,此时低四位全部为1,高28位全部为0,当0进行&运算时结果必然为0,因此此时hashCode与“table.length-1”的&运算只取决于hashCode的低四位,在这种情况下,hashCode的高28位就没起到任何作用,并且由于hash结果只取决于hashCode的低4位,hash冲突的概率也会增加。因此,在JDK1.8中,将高位也参与计算,目的是为了降低hash冲突的概率。

技术图片

 

 

 get方法:

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
 
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 1.对table进行校验:table不为空 && table长度大于0 && 
    // table索引位置(使用table.length - 1和hash值进行位与运算)的节点不为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 2.检查first节点的hash值和key是否和入参的一样,如果一样则first即为目标节点,直接返回first节点
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 3.如果first不是目标节点,并且first的next节点不为空则继续遍历
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                // 4.如果是红黑树节点,则调用红黑树的查找目标节点方法getTreeNode
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                // 5.执行链表节点的查找,向下遍历链表, 直至找到节点的key和入参的key相等时,返回该节点
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    // 6.找不到符合的返回空
    return null;
}

4.如果是红黑树节点,则调用红黑树的查找目标节点方法 getTreeNode。

final TreeNode<K,V> getTreeNode(int h, Object k) {
    // 1.首先找到红黑树的根节点;2.使用根节点调用find方法
    return ((parent != null) ? root() : this).find(h, k, null);
}

2.使用根节点调用 find 方法。

 

/**
 * 从调用此方法的节点开始查找, 通过hash值和key找到对应的节点
 * 此方法是红黑树节点的查找, 红黑树是特殊的自平衡二叉查找树
 * 平衡二叉查找树的特点:左节点<根节点<右节点
 */
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
    // 1.将p节点赋值为调用此方法的节点,即为红黑树根节点
    TreeNode<K,V> p = this;
    // 2.从p节点开始向下遍历
    do {
        int ph, dir; K pk;
        TreeNode<K,V> pl = p.left, pr = p.right, q;
        // 3.如果传入的hash值小于p节点的hash值,则往p节点的左边遍历
        if ((ph = p.hash) > h)
            p = pl;
        else if (ph < h) // 4.如果传入的hash值大于p节点的hash值,则往p节点的右边遍历
            p = pr;
        // 5.如果传入的hash值和key值等于p节点的hash值和key值,则p节点为目标节点,返回p节点
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;
        else if (pl == null)    // 6.p节点的左节点为空则将向右遍历
            p = pr;
        else if (pr == null)    // 7.p节点的右节点为空则向左遍历
            p = pl;
        // 8.将p节点与k进行比较
        else if ((kc != null ||
                  (kc = comparableClassFor(k)) != null) && // 8.1 kc不为空代表k实现了Comparable
                 (dir = compareComparables(kc, k, pk)) != 0)// 8.2 k<pk则dir<0, k>pk则dir>0
            // 8.3 k<pk则向左遍历(p赋值为p的左节点), 否则向右遍历
            p = (dir < 0) ? pl : pr;
        // 9.代码走到此处, 代表key所属类没有实现Comparable, 直接指定向p的右边遍历
        else if ((q = pr.find(h, k, kc)) != null) 
            return q;
        // 10.代码走到此处代表“pr.find(h, k, kc)”为空, 因此直接向左遍历
        else
            p = pl;
    } while (p != null);
    return null;
}

 明天再写

以上是关于hashmap详解(基于jdk1.8)的主要内容,如果未能解决你的问题,请参考以下文章

Java开发大牛用代码演示基于JDK1.6版本下的HashMap详解

HashMap详解(基于JDK 1.8)

JDK1.7中HashMap死环问题及JDK1.8中对HashMap的优化源码详解

jdk1.8 HashMap的扩容resize()方法详解

面试必看-基于JDK1.8的HashMap

源码解析JDK1.8-HashMap链表成环的问题解决方案