Java经典八股文之HashMap

Java相关文章

• Java内存模型
• Java中String特性
• Java对象内存布局
• JVM结构
• JVM垃圾回收器
• Java19虚拟线程新特性
• Java线程生命周期与常见方法
• Java线程池笔记
• 浅谈synchronized锁原理
• 浅谈AQS原理
• ThreadLocal原理
• 浅谈双亲委派模型
• Java中的NIO
• Thread.sleep(0)的作用

HashMap原理

内部结构

1. HashMap内部使用数组+链表（链表长度>8 & 数组大小>64转化为红黑树结构）
2. hashmap允许key为null但不能重复

为什么要使用红黑树？

1. 树化是为了hash碰撞严重时链表长度过长，查找复杂度为on
2. 使用红黑树查询复杂度logn，插入复杂度logn
3. 根据泊松分布，在负载因子0.75(HashMap默认)的情况下，单个hash槽内元素个数为8的概率小于百万分之一，将7作为一个分水岭，等于7时不做转换，大于等于8才转红黑树，小于等于6才转链表。

为什么不采用AVL树或B树？

1. 红黑树更通用，在添加、删除、查找的时间复杂度都为logn
2. AVL树查询快，但添加、删除慢

为什么默认不传值数组大小为16？

1. 传值初始化大小为大于传值的最小2^n
2. hashmap的大小始终为2的幂 ，因为计算存放位置时，要将计算出的hash值和hashmap长度-1进行&与运算（同1为1其余都是0)，如果是奇数-1最后一位都是0，0&任何数都是0，浪费位数
3. 取余操作中如果除数是2的幂次则等价于与其除数减一的与操作 （也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）。” 并且采用二进制位操作 ,相对于取余操作能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。

为什么扩容因子是0.75

1. 符合泊松分布
2. 扩容因子太大hash冲突会频繁，扩容因子太小空间浪费，查询效率会底
3. 0.75刚刚好

put原理

1. 对key的hashcode进行hash计算得到下标
2. 判断是否存在hash碰撞
3. 如果碰撞了以链表的形式放在bucket里
4. 如果链表长度过长（大于默认值8），则把链表转换成红黑树
5. 如果节点存在则替换value
6. 如果数组长度大于了 当前容量*负载因子则进行resize

hash运算

1. hash方法实际是让key.hashCode()与key.hashCode()>>>16进行异或操作
2. 扰动函数降低hash碰撞几率

get原理

1. 对key的hashCode()做hash运算，计算index;
2. 如果在bucket⾥的第⼀个节点⾥直接命中，则直接返回；
3. 如果有冲突，则通过key.equals(k)去查找对应的Entry;
4. 若为树，则在树中通过key.equals(k)查找，O(logn)；
5. 若为链表，则在链表中通过key.equals(k)查找，O(n)。

扩容（resize）原理

1. 每次扩容都为原来的2倍
2. 扩展后 Node 对象的位置要么在原位置，要么移动到原偏移量两倍的位置
3. 1.7 ，扩容之后需要重新去计算其 Hash 值，根据 Hash 值对其进行分发.
4. 1.8 ，则是根据在同一个桶的位置中进行判断(e.hash & oldCap)是否为 0，0 -表示还在原来位置，否则就移动到原数组位置 + oldCap。
5. 重新进行 hash 分配后，该元素的位置要么停留在原始位置，要么移动到原始位置+增加的数组大小这个位置上。

rehash源码

void transfer(Entry[] newTable) {
    Entry[] src = table;                   //src引用了旧的Entry数组
    int newCapacity = newTable.length;
    for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
        Entry<K, V> e = src[j];             //取得旧Entry数组的每个元素
        if (e != null) {
            src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
            do {
                Entry<K, V> next = e.next;
                int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
                e.next = newTable[i]; //标记[1]
                newTable[i] = e;      //将元素放在数组上
                e = next;             //访问下一个Entry链上的元素
            } while (e != null);
        }
    }
}

为什么线程不安全

1. 扩容时，table数组是线程共享的，newtable是线程不共享的
2. transfer函数执行完会执行table = newtable其他线程就可以看到转移线程转移后的结果了
3. jdk1.7之前使用头插法导致扩容后数组反转，多线程下产生环、数据覆盖
4. 产生环的原因

1. 一是头插法
2. 二是Java内存模型导致多线程下当被另一个线程执行完扩容后，新数组都是头插法执行后的逆序状态。没及时更新主存数据