HashMap 常见面试题（含1.7 和 1.8 对比）

最新推荐文章于 2024-11-04 19:24:37 发布

Jerry.ZZZ

最新推荐文章于 2024-11-04 19:24:37 发布

阅读量887

点赞数 23

文章标签：哈希算法散列表算法

本文链接：https://blog.csdn.net/qq_43710228/article/details/142503196

版权

简介

HashMap 是基于哈希表的数据结构，用于存储键值对 (key-value)。其核心是将键的哈希值映射到数组索引位置，通过数组+链表(在 Java8及之后是数组 +链表+红黑树)来处理哈希冲突。

Hashmap 使用键的 hashcode()方法计算哈希值，并通过 indexFor 方法确定元素在数组中的存储位置。哈希值是经过一定扰动处理的，防止哈希值分布不均匀，从而减少冲突。

HashMap 的默认初始容量为 16，负载因子为 0.75。也就是说，当存储的元素数量超过 16x0.75= 12 个时，会触发扩容操作，容量乘 2 并重新分配元素位置。这种扩容是比较耗时的操作，频繁扩容会影响性能。

底层数据结构

1.7

数组+链表

1.8

数组+链表 + 红黑树

key 的 hash 值计算方式

1.7

四次异或，性能较差.
对 null put 时进行了单独处理，直接去找数组下标为0的链表。

static int hash(int h) {

    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

1.8

将 key 的哈希码的高 16 位和低 16 位进行异或。因为(n - 1) & hash是 table 的索引，n 的长度不够大时，只和 hashCode() 的低 16 位有关，这样发生冲突的概率就变高。通过将高 16 位和低 16 位进行异或可以减少冲突。
null 的哈希值为 0

    static final int hash(Object key) {
      int h;
      // key.hashCode()：返回散列值也就是hashcode
      // ^：按位异或
      // >>>:无符号右移，忽略符号位，空位都以0补齐
      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

put 方法

1.7

首先根据 hash 算法计算出 hash 值，然后通过 (n-1) & hash 得到数组下标。
如果定位到的数组位置没有元素，就直接插入。
如果定位到的数组位置有元素，遍历以这个元素为头结点的链表，依次和链表上的 key 比较，如果存在key 相同的节点就直接覆盖，没有相同的节点就采用头插法将元素插入链表。（多线程情况下，头插法可能导致链表形成环，特别是在并发扩容时。）

1.8

首先根据 hash 算法计算出 hash 值，然后通过 (n-1) & hash 得到数组下标。
如果定位到的数组位置没有元素，就直接插入。
如果定位到的数组位置有元素，遍历以这个元素为头结点的链表（红黑树），依次和链表上的 key 比较，如果存在key 相同的节点就直接覆盖，没有相同的节点就采用尾插法（）将元素插入链表。
当链表长度 > 8 并且数组大小 >=64 时就把链表转化为红黑树；当红黑树节点 < 6 时，又会退化成链表。

get 方法

1.7

首先根据 hash 算法计算出 hash 值，然后通过 (n-1) & hash 得到数组下标。
如果定位到的数组位置没有元素，就返回 null。
如果定位到的数组位置有元素，遍历以这个元素为头结点的链表，依次和链表上的 key 比较，如果存在key 相同的节点就返回，否则返回 null。

1.8

首先根据 hash 算法计算出 hash 值，然后通过 (n-1) & hash 得到数组下标。
如果定位到的数组位置没有元素，就返回 null。
如果定位到的数组位置有元素，遍历以这个元素为头结点的链表（红黑树），依次和链表上的 key 比较，如果存在key 相同的节点就返回，没有相同的节点就返回 null。

扩容

扩容都是在新增数据时进行的。

1.7

只有 size >= 阈值，并且要插入的桶非空才会进行扩容。
扩容时，进入到 resize 方法，重新计算所有元素的哈希值，并将它们重新分配到新的哈希桶中。（头插法）

public V put(K key, V value) {
        //各种条件判断，key是否存在，是否为空...
        if () {
            ...
        ...
        //封装所需参数，准备添加
        addEntry(hash, key, value, i);
        return null;
    }
    
void addEntry(int hash, K key, V value, int bucketIndex) {
        //判断是否需要扩容
        if ((size >= threshold) && (null != table[bucketIndex])) {
            //扩容
            resize(2 * table.length);
            //重新计算hash值
            hash = (null != key) ? hash(key) : 0;
            //计算所要插入的桶的索引值
            bucketIndex = indexFor(hash, table.length);
        }
        //执行新增Entry方法
        createEntry(hash, key, value, bucketIndex);
    }

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        //达到最大值，无法扩容
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        Entry[] newTable = new Entry[newCapacity];
        //将数据转移到新的Entry[]数组中
        transfer(newTable, initHashSeedAsNeeded(newCapacity));//初始化散列种子
        //覆盖原数组
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

1.8

由于数组的长度是 2 的次方，且扩容为 2 倍。那么通过 (n-1) & hash 计算数组下标时，新的下标和原下标的关系只可能是：
新下标 = 原下标
新下标 = 原下标 + 原数组大小
举例：原数组大小为 16（010000），扩容后数组大小为 32（100000）
16-1 = 15（001111）
32-1 = 31（011111）
通过 (n-1) & hash 计算下标，hash 不变，新下标和旧下标的区别只在于高位是否为 1，如果是 1 说明需要搬到新位置，如果是 0 则保持不变。而刚好可以通过原数组的长度（10000）判断高位是否为 1。因此扩容过程如下：

遍历每个桶：将每个元素的哈希与原数组长度相与，等于 0 的和等于 1 的分别存在一个链表中。所有元素遍历完后，等于 0 的链表直接放在新数组的原位置，等于 1 的直接放在新数组的原下标 + 原数组大小的位置上。

可以看出 1.8 的搬迁元素是一个桶的链表一起搬的，而不是一个一个搬。