亲宝软件园·资讯

展开

HashMap源码个人解读

=凌晨= 人气:0

HashMap的源码比较复杂,最近也是结合视频以及其余大佬的博客,想着记录一下自己的理解或者当作笔记

JDK1.8后,HashMap底层是数组+链表+红黑树。在这之前都是数组+链表,而改变的原因也就是如果链表过长,查询的效率就会降低,因此引入了红黑树。

 

这里的链表是一个单向链表

 static class Node<K,V> implements Map.Entry<K,V> {
        final int 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() {
            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) {
            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;
        }
    }

接下来是类的属性

 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16默认的初始容量是16

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量

    /**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;//负载因子

    /**
     * The bin count threshold for using a tree rather than list for a
     * bin.  Bins are converted to trees when adding an element to a
     * bin with at least this many nodes. The value must be greater
     * than 2 and should be at least 8 to mesh with assumptions in
     * tree removal about conversion back to plain bins upon
     * shrinkage.
     */
    static final int TREEIFY_THRESHOLD = 8;//树化阈值

    /**
     * The bin count threshold for untreeifying a (split) bin during a
     * resize operation. Should be less than TREEIFY_THRESHOLD, and at
     * most 6 to mesh with shrinkage detection under removal.
     */
    static final int UNTREEIFY_THRESHOLD = 6;//树降级成为链表的阈值

    /**
     * The smallest table capacity for which bins may be treeified.
     * (Otherwise the table is resized if too many nodes in a bin.)
     * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
     * between resizing and treeification thresholds.
     */
    static final int MIN_TREEIFY_CAPACITY = 64;//桶中的结构转化为红黑树对应的table,也就是桶的最小数量。

transient Node<K,V>[] table;//存放元素的数组,总是2的幂次方

    /**
     * Holds cached entrySet(). Note that AbstractMap fields are used
     * for keySet() and values().
     */
    transient Set<Map.Entry<K,V>> entrySet;存放具体元素的集

    /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;存放元素的个数,不是数组的长度

    /**
     * The number of times this HashMap has been structurally modified
     * Structural modifications are those that change the number of mappings in
     * the HashMap or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the HashMap fail-fast.  (See ConcurrentModificationException).
     */
    transient int modCount;//每次扩容和更改map结构的计数器

    /**
     * The next size value at which to resize (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;//临界值,当实际大小(容量*负载因子)超过临界值时,会进行扩容

    /**
     * The load factor for the hash table.
     *
     * @serial
     */
    final float loadFactor;//负载因子

构造方法中将两个参数的构造方法

 public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)//初始容量不能小于0,否则报错
throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY)//初始容量不能大于最大值,否则为最大值 initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor))//负载因子不能小于或者等于0,不能为非数字 throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor;//初始化填充因子 this.threshold = tableSizeFor(initialCapacity);//初始化threshold大小 }
tableSizeFor(initialCapacity)这个方法的作用就是返回大于等于initialCapacity的最小的二的次方数。注意是最小
    /**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;//0b1001
        n |= n >>> 1;//1001 | 0100 = 1101
        n |= n >>> 2;//1101 | 0011 = 1111
        n |= n >>> 4;//1111 | 0000 = 1111
        n |= n >>> 8;
        n |= n >>> 16;//那么后面这两步就得到的结果还是1111。
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;//1111就是15.加1等于16
    }

加色cap等于10,那么n = 10-1 = 9。n转化为二进制的话,就是0b1001。那么无符号右移一位,就是0100。

这里cap-1的操作就是为了保证最后得到的n是最小的大于等于initialCapacity的二的次方数。比如这里比10大的2的次方数就是16。如果没有减1.经过上述多次右移和或运算之后,得到的就不是16了。而是32。就不是最小的了。就变成了2倍了。

接下来分析put方法。

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

首先研究hash(key)这个方法

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

这个就叫扰动函数,他让hash值得高16位与第16位进行异或处理。这样可以减少碰撞。采用位运算也是因为这样更高效。并且当数组的长度很短时,只有低位数的hashcode值能参与运算。而让高16位参与运算可以更好的均匀散列,减少碰撞,进一步降低hash冲突的几率。并且使得高16位和低16位的信息都被保留了。

然后讲述putVal方法,执行过程可以用下面图来理解:

1.判断数组table是否为空或者位null,否则执行resize()进行扩容;

2.根据键值key计算数组hash值得到插入的数组索引i,如果table[i]==null,那么就可以直接新建节点添加到该处。转向6,如果不为空,转向3

3.判断table[i]的首个元素是否和key一样,如果相同直接覆盖value,否则转向4,这里的相同指的是hashCode以及equals;
4.判断table[i] 是否为treeNode,即table[i] 是否是红黑树,如果是红黑树,则直接在树中插入键值对,否则转向5;
5.遍历table[i],判断链表长度是否大于8(且),大于8的话(且Node数组的数量大于64)把链表转换为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;
6.插入成功后,判断实际存在的键值对数量size是否超多了最大容量threshold,如果超过,进行扩容。
————————————————
版权声明:本文为CSDN博主「钱多多_qdd」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/moneywenxue/article/details/110457302

源码如下:

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;//定义了辅助变量tab:引用当前hashMap的散列表;p:表示当前散列表的元素,n:表示散列表数组的长度 i:表示路由寻址结果
      //这里是延迟初始化逻辑,第一次调用putVal时会初始化hashMap对象中的最耗内存的散列表
//    步骤1 if ((tab = table) == null || (n = tab.length) == 0)//table就是Hash,table就是HashMap的一个数组,类型是Node[],这里说明散列表还没创建出来 n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null)//n在上面已经赋值了。这是步骤2。 tab[i = (n - 1) & hash])这一块就是路由算法,赋予p所在table数组的位置,并把这个位置的对象,赋给p,如果这个位置的节点位null,那么表示这个位置还没存放元素。 tab[i] = newNode(hash, key, value, null);就在该位置创建一个新节点,这个新节点封装了key value else {//桶中这个位置有元素了 Node<K,V> e; K k;//步骤3 if (p.hash == hash &&//如果当前索引位置对应的元素和准备添加的key的hash值一样 ((k = p.key) == key || (key != null && key.equals(k))))并且满足准备加入的key和该位置的key是同一个对象,那么后续就会进行替换操作。 e = p; else if (p instanceof TreeNode)//步骤4.判断该链是否是红黑树 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);如果是,则放入该树中 else {//步骤5 该链为链表 使用尾插法插入数据 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) {//桶的位置的next为e,如果e为null,在for的循环中就说明没有找到一样的key的位置,那么久加入末尾 p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st加入后判断是否会树化 treeifyBin(tab, hash); break;//然后跳出 } if (e.hash == hash &&//这种情况就是找到了一个key以及hash都一样了,那么久要进行替换。 ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e;//这是循环用的,与前面的e=p.next组合,可以遍历链表。 } } if (e != null) { // existing mapping for key//这里就是替换操作,表示在桶中找到key值,hash值与插入元素相等的节点 V oldValue = e.value;//记录e的value if (!onlyIfAbsent || oldValue == null) e.value = value;//用心智替换旧值, afterNodeAccess(e);//访问后回调 return oldValue;//返回旧值 } } ++modCount;//结构性修改 if (++size > threshold)//步骤6,如果超过最大容量就扩容。 resize(); afterNodeInsertion(evict);//插入后回调 return null; }

 总结一下流程:1根据key计算得到key.hash = (h = k.hashCode())^(h>>>16);

2.根据key.hash计算得到桶数组中的索引,其路由算法就是index = key.hash &(table.length-1),就是哈希值与桶的长度-1做与操作,这样就可以找到该key的位置

2.1如果该位置没有数据,那正好,直接生成新节点存入该数据

2.2如果该位置有数据,且是一个红黑树,那么执行相应的插入/更新操作;

2.3如果该位置有数据,且是一个链表,如果该链表有这个数据,那么就找到这个点并且更新这个数据。如果没有,则采用尾插法插入链表中。

接下来讲解最重要的resize()方法。

扩容的目的就是为了解决哈希冲突导致的链化影响查询效率的问题。扩容可以缓解。

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//oldTab引用扩容前的哈希表
     ////oldCap表示扩容之前table数组的长度
      //oldTab==null就是第一次new HashMap()的时候,那时候还没有放值,数组就是null。那么初始化的时候
      //也要扩容。这句就是如果旧的容量为null的话,那么oldCap是0,否则就是oldTab的长度 int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold;//表示扩容之前的扩容阈值,也就是触发本次扩容的阈值
    //newCap:扩容之后table数组的大小
//newThr:扩容之后,下次再次触发扩容的条件 int newCap, newThr = 0; if (oldCap > 0) {//条件如果成立,那么就是代表hashMap中的散列表已经初始化过了,这是一次正常的扩容 if (oldCap >= MAXIMUM_CAPACITY) {//扩容之前的table数组大小已经达到最大阈值后,则不扩容,且设置扩容条件为int最大值,这种情况非常少数 threshold = Integer.MAX_VALUE; return oldTab; }
        //oldCap左移一位实现数值翻倍,并且赋值给newCap,newCap小于数组最大值限制 且 扩容之前的阈值>=16
* //这种情况下,则下一位扩容的阈值等于当前阈值翻倍 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold这里阈值翻倍也可以理解,如果原先table是16长度,那么oldThr就是16*0.75=12;那么oldCap翻倍的时候,那么新的阈值就是2*16*0.75 = 24; }
     //这是oldCap==0的第一种情况,说明hashMap中的散列表是null
     //哪些情况下散列表为null,但是阈值却大于零呢
    //1.new HashMap(initCap,loadFactor);
    //2.new HashMap(initial);
    //3.new HashMap(map);并且这个map有数据,着三种情况下oldThr是有值得 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { 这是oldCap==0,oldThr==0的情况,是new HashMap();的时候// zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY;//16 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//12 } if (newThr == 0) {//newThr为0时,通过newCap和loadFactor计算出一个newThr 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];//创建一个大小为newCap的新的数组 table = newTab;//把新的数组赋值给table if (oldTab != null) {//说明hashmap本次扩容之前,table不为null for (int j = 0; j < oldCap; ++j) {//将旧数组中的所有数据都要处理,所以来个循环 Node<K,V> e;//当前node节点 if ((e = oldTab[j]) != null) {//说明当前桶位中有数据,但是数据具体是单个数据,还是链表还是红黑树并不知道 oldTab[j] = null;//将旧的数组的这个点置空,用于方便VM GC时回收内存 if (e.next == null)//如果当前的下一个不为空,也就是在桶位中是单个数据, newTab[e.hash & (newCap - 1)] = e;//那么根据路由算法e的hash与上新的table的长度-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;
                //假如oldCap = 16,那么就是0b10000
                //假如hash为 .....1 1111.前面的不用看,就看着五位
                //或者hash为 .....0 1111.
                那么与上 000000.. 1 0000.前面都是0。所以与完之后,如果为0,那么就是下面这种.....0 1111,就代表应该在低位链。 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) {//如果原先旧数组中的链表中低位链后面不为null,也就是后面是高位链的。复制到新的数组中就要置为null。 loTail.next = null; newTab[j] = loHead;//然后把这个低链表的头节点放到新的数组中的索引位置。这样低位链的这个节点,就到了新的数组的地方了 } if (hiTail != null) {//同理 hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }

从下图可以看出上面扩容的第三种情况,链表的情况。在第15这个桶位的时候,为啥扩容到32的长度的时候,有的链表节点还在15,而有一些却到31处了。因为旧数组中的索引15是根据路由算法算出来的,

公式为hash&(table.length-1),此时索引为15,那么就是hash&(table.length-1) =15.又因为table.length-1=15,也就是1111,那么hash的低四位肯定就知道了,也是1111,但是第五位就不知道了有可能是1有可能

是0,也就是11111或者01111.那么在新的数组中求索引的时候,根据路由算法,此时新的数组长度为32,那么32-1=31,也就是11111那么旧数组中的数如果是11111,那么算出来就是11111,就是在新数组

31的位置上,如果是01111,那么与之后就是01111。就还是15。别的位置也是这样,如果是原索引为1的地方,那么有可能到新数组的17的位置,就是1+16=17;不是都是加16;而是加这个旧数组的长度。

 

接下来是get()方法;

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;//这里hash(key)的原因是因为存的时候,hash了一下,那么取的时候,肯定的要取他的hash值一样的。
    }

所以主要是getNode方法:

final Node<K,V> getNode(int hash, Object key) {
    ////tab:引用当前hashMap的散列表
    //first:桶位中的头元素
    //e:临时node元素
     //n:table数组长度 Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && //(tab = table) != null&& (n = tab.length) > 0表示散列表不为空,这样才能取到值,要不然没有水的水池不可能取到水。 (first = tab[(n - 1) & hash]) != null) {//这个代表在这个索引的位置的头节点不为null。也就是这个地方有数据。 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first;//如果头元素就是正好要找的数据,那么直接返回头元素 if ((e = first.next) != null) {//如果这个桶的索引处不是单个数据,那么就进一步查找,如果是单个元素,那么下面不执行,直接返回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;//如果找到一样的e,那么就返回,否则就一直循环,到结尾的话,就还没找到,那么就返回null } while ((e = e.next) != null); } } return null;//如果上述条件不满足,也就是桶为null或者在指定位置没有数据,那么就返回null }

接下来是remove(Object key)方法。

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

其实就是removeNode方法

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
    //matchValue是用来判断的,因为remove还有一个方法,是两个参数的,remove(Object key, Object value).这个方法也是套娃了removeNode方法,意思是不仅key得一致,value也得一致才能删除。否则删不了。matchValue就是用来做这个判断得
* //tab:引用当前hashMap中的散列表
* //p:当前node元素
* //n:表示散列表数组长度
* //index:表示寻址结果,索引位置。 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) {//找到对应的桶位是有数据的,要不然为null还删啥 Node<K,V> node = null, e; K k; V v; //node为查找到的结果, e表示当前node的下一个元素 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))//当前定位的桶位的索引处的头节点就是要找的结果 node = p;//那么把p赋值给node 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;//这里条件是说明如果是链表中的某一个,那么就找到了这个节点,并把则会个结果赋值给node。用于返回。并退出循环 break; } p = e;//这里是还没找到继续挨个迭代 } while ((e = e.next) != null); } }//上述是查找过程。下面是删除过程 if (node != null && (!matchValue || (v = node.value) == value ||//!matchValue || (v = node.value) == value就是用来判断值是否需要判断一样再删除,就是两个参数的remove方法的条件。如果不是,那么!matchValue就是对的,后面值得判断就不用判断了 (value != null && value.equals(v)))) {//这里就是判断是否是要删除这个节点。 if (node instanceof TreeNode)//这种情况代表结果是树的节点。就走树的删除逻辑 ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p)//当当前桶位的元素就是要删除的元素,那么node才会等于p,那么就把node之后的头节点放到这个桶位就行 tab[index] = node.next; else p.next = node.next;//链表的情况的时候,node一定是在后面。因为上述查找过程中e一直都是p.next,e又赋值给node。所以node就在p后面。这里删除node节点就行。 ++modCount; --size; afterNodeRemoval(node); return node; } } return null; }

 replace方法主要是调用getnode。上文已经讲述过了。这里不赘述。

注意:链表转化为红黑树的条件是当前桶位中的节点数到达8并且散列表的长度大于等于64。

还有table扩容的时候,并不是只是桶位的第一个元素才算。根据添加函数中的size++;size是只要加入一个元素,就加1.也就是加入的元素不是桶位第一个元素,而是加到红黑树或者链表中了。也算。这样只要达到了阈值0.75*长度。散列表table就会扩容。

加载全部内容

相关教程
猜你喜欢
用户评论