HashMap面试背诵详解

HashMap面试背诵详解

0.HashMap的基本属性

1. HashMap的结构：
   JDK1.7及之前是使用数组+链表实现，JDK1.8之后使用数组+链表+红黑树实现
2. HashMap的初始容量和加载因子：
   初始容量为16，加载因子为0.75
3. 扰动函数：
   (h = key.hashCode()) ^ (h >>> 16) 把hash值右移16位，让高位参与运算，增大了「随机性」，扰动函数就是为了增加随机性，让数据元素更加均衡的散列，减少碰撞。

1. HashMap的putVal方法

1. 首先会根据Key的哈希值计算出Key应该存放的位置，使用的是 hash & (length-1)
   考点1: hash值的返回值是什么类型？可以表示多大的范围？
   答案：hash值返回值为int类型，可以表示2³²的数据量，区间为-2³¹ 至 2³¹-1范围
   考点2: 为什么使用hash & (length - 1)
   答案：因为其等价于hash%length，同时使用&提高效率，由于位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快
   考点3: 为什么等价于hash%length，原理是什么？
   答案：因为HashMap的length始终为2的次幂，比如初始长度为16，二进制就是1 0000，其减一之后的二进制为0 1111，与上任何数的区间都在0000-1111之间，达到了取模的效果。
2. 然后会判断此时下标为hash & (length-1) 的数组元素是否为空：如果为空，就创建一个Node（key,value）, 并将其存放在此位置，结束；如果不为空，进入else判断语句
3. 进入else语句，说明此时存在值，首先对第一个节点与要插入的Key值进行比较：如果相等，再比较两元素是否为同一对象或者其两对象equals值是否相等（引用同一对象）；如果不想等，进入下一个else if判断语句
   考点5: 如何判断两个key是否重复？
   答案：先对hashcode进行对比判断，如果不一样，则key不重复；如果一样，则使用equals方法进行判断或者判断两个元素是否为同一个对象
   考点4: 为什么还要进行equals的判断？
   答案：因为hashcode相等的值，其不一定是同一个对象，但是hashcode不想等的值，其一定是不同的对象。先利用hashcode进行判断，提高效率，发生冲突之后再进行equals判断，如果没有重写equals方法，则使用Object类中默认的equals方法判断两个对象的内存地址是否相同。
4. 然后再判断节点是否树化，如果树化，则使用红黑树的方法进行比较；如果还没有树化，则进入else判断语句
5. 此时迭代遍历链表，如果相等则进行替换，如果不相等，则加入在尾部（尾插法）
6. 最后判断链表的节点数目是否大于8，数组长度是否大于64，两者都满足才会将链表转为红黑树

//V:添加的元素Key不重复：返回null;key重复：返回原有key对应的value值
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    HashMap.Node[] tab;
    int n;
    //this.table:存放node节点的数组
    if ((tab = this.table) == null || (n = tab.length) == 0) {
        //this.resize()：此方法对table进行了初始化空间大小为16，
        n = (tab = this.resize()).length;
    }

    Object p;
    int i;
    //根据key的哈希值计算此key应该存放在table表的那个索引位置
    //再判断p是否为null
    //p为空表示还没有存放元素，就创建一个Node（key,value）,并将其存放在此位置
    if ((p = tab[i = n - 1 & hash]) == null) {
        tab[i] = this.newNode(hash, key, value, (HashMap.Node)null);
    } else {
        Object e;
        Object k;
        /**
        *先比较的是当前索引位置对应链表的第一个位置的元素（p）与要添加的key值的元素是否相等，
        不相等：产生短路与进行下一判断条件
        相等：再比较两元素是否为同一对象或者其两对象equals值是否相等（引用同一对象），满足其中一个条件则
        此key值已存在，它添加失败，给e赋值为原有的值并在下方返回。
        */
        if (((HashMap.Node)p).hash == hash && ((k = ((HashMap.Node)p).key) == key || key != null && key.equals(k))) {
            e = p;
         //再判断p是不是一棵红黑树，按照红黑树的方法进行比较
        } else if (p instanceof HashMap.TreeNode) {
            e = ((HashMap.TreeNode)p).putTreeVal(this, tab, hash, key, value);
        //进入这个条件，说明它是一个链表，则让Key与以p为起点的链表上的所有节点值循环比较，相等退出，不相等添加在链表的最后
        } else {
            int binCount = 0;//记录遍历到的第binCount个节点
            while(true) {
                //key依次与链表的每一个元素比较后都不相同，则创建其相关节点并添加到链表的最后
                //将元素添加到链表最后立即判断此时链表的长度是否满足树化条件
                if ((e = ((HashMap.Node)p).next) == null) {
                    ((HashMap.Node)p).next = this.newNode(hash, key, value, (HashMap.Node)null);
                    //当链表长度等于8时，将此链表转化为红黑树
                    if (binCount >= 7) {
                        //此时调用此方法不一定真正进行树化，会再进行判断数组的大小是否达到64
                        //达到：进行树化，未达到进行数组扩容。
                        this.treeifyBin(tab, hash);
                    }
                    break;
                }
				//key与该链表的每一个元素比较后出现相同的情况直接break，在后面方法会返回此节点的值。
                if (((HashMap.Node)e).hash == hash && ((k = ((HashMap.Node)e).key) == key || key != null && key.equals(k))) {
                    break;
                }

                p = e;
                ++binCount;
            }
        }

        if (e != null) {
            //将原位置的value值进行缓存
            V oldValue = ((HashMap.Node)e).value;
            if (!onlyIfAbsent || oldValue == null) {
                //将新的value值替换原有的value值
                ((HashMap.Node)e).value = value;
            }
            this.afterNodeAccess((HashMap.Node)e);
            return oldValue;//返回的是原位置的value
        }
    }

    ++this.modCount;
    //threshold:临界值，根据当前数组容量与加载因子（默认0.75）计算得出
    //若当前数组中节点个数大于此临界值则需要扩容 
    if (++this.size > this.threshold) {
        this.resize();
    }
	//此方法为HashMap留给其子类实现的（实现一个有序链表等），对于hashMap来说此方法为一个空方法
    this.afterNodeInsertion(evict);
    return null;
}

2. HashMap的扩容机制

1. 当数组的容量达到阈值(数组大小 x 加载因子)，初始值为16 * 0.75 = 12，数组需要进行扩容为原来大小的两倍吗，第一次会从16扩容至32
   考点5: 为什么选择2倍，而不是1.5倍，2.5倍？
   答案：由于HashMap的数组大小始终要保持为2的n次幂，为什么是保持2的n次幂，文章之前已经说明了
2. 如果旧桶中没有数据，则不做处理；如果有数据，分为三种情况分别进行处理：单个节点、链表、红黑树
3. 如果为单个节点，使用 e.hash & (newCap - 1) 寻址进行插入，oldCap=12，newCap=12，下标位置没有变化
4. 如果为链表，进行高低链拆分，举个例子：oldCap=15 二进制后四位为1111，在这个桶内的key的hash值后四位都是1，倒数第五位不同，可能为1，也可能为0，通过 & (newCap-1)，也就是1 1111，通过与运算只有两种结果1 1111 和0 1111，1 1111放入高位链，0 1111放入低位链，就完成了链表的拆分
5. 如果是红黑树，内部维系了链表的结构，与链表拆分的步骤一样，分为高位链和低位链，如果新的链表长度达到6，则进行树化，否则保存为链表

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    // Cap 是 capacity 的缩写，容量。如果容量不为空，则说明已经初始化。
    if (oldCap > 0) {
        // 如果容量达到最大1 << 30则不再扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 按旧容量和阀值的2倍计算新容量和阀值
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
    
        // initial capacity was placed in threshold 翻译过来的意思，如下；
        // 初始化时，将 threshold 的值赋值给 newCap，
        // HashMap 使用 threshold 变量暂时保存 initialCapacity 参数的值
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        // 这一部分也是，源代码中也有相应的英文注释
        // 调用无参构造方法时，数组桶数组容量为默认容量 1 << 4; aka 16
        // 阀值；是默认容量与负载因子的乘积，0.75
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    
    // newThr为0，则使用阀值公式计算容量
    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"})
        // 初始化数组桶，用于存放key
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 如果旧数组桶，oldCap有值，则遍历将键值映射到新数组桶中
        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)
                    // 这里split，是红黑树拆分操作。在重新映射时操作的。
                    ((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;
                    // 这里是链表，如果当前是按照链表存放的，则将链表节点按原顺序进行分组{这里有专门的文章介绍，如何不需要重新计算哈希值进行拆分《HashMap核心知识，扰动函数、负载因子、扩容链表拆分，深度学习》}
                    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;
}