Java集合篇之HashMap解析与源码分析

HashMap是Java集合框架中最常用的数据结构之一，它基于哈希表实现，提供了快速的查找、插入和删除操作。HashMap允许存储null键和null值，并且是非线程安全的。本文将深入解析HashMap的源码，帮助读者更好地理解其内部实现机制。

1. HashMap概述

HashMap是Map接口的一个实现类，它基于哈希表实现，允许存储键值对。HashMap通过哈希函数将键映射到哈希表中的某个位置，从而实现快速的查找、插入和删除操作。

1.1 主要特点

• 基于哈希表：HashMap内部使用哈希表来存储键值对，通过哈希函数将键映射到哈希表中的某个位置。
• 快速查找：HashMap的查找、插入和删除操作的平均时间复杂度为O(1)。
• 允许null键和null值：HashMap允许存储null键和null值。
• 非线程安全：HashMap不是线程安全的，如果在多线程环境下使用，需要手动进行同步处理。

1.2 核心数据结构

    数组 + 链表 + 红黑树（JDK 1.8+）

• 数组（Node<K,V>[] table）：存储哈希桶（Bucket），初始化容量为 2的幂次方（默认16）。
• 链表：解决哈希冲突，当哈希值相同时，元素以链表形式存储。
• 红黑树：链表长度超过 8 时，链表转为红黑树（树化阈值）；长度低于 6 时退化为链表（反树化阈值）。【当链表长度≥8时触发树化（需满足数组长度≥64，否则优先扩容）】
  优化目的：避免链表查询效率退化为O(n)，树化后查询复杂度为O(log n)。

1.3 核心参数

• 负载因子（Load Factor）：默认 0.75，权衡空间占用与哈希冲突概率。
• 扩容阈值（Threshold）：容量 * 负载因子，触发扩容的临界值。
• 默认容量：16，最大容量 1 << 30。

2. HashMap源码解析

一、哈希计算与扰动函数

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

• 目的：通过 高位与低位异或，减少哈希冲突（如 hashCode 高位变化大，但数组长度小时低位可能重复）。
• 示例：假设 hashCode 为 0xFFFF0000，右移16位后异或，得到更均匀的哈希值。

---

二、put 方法核心逻辑

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

final V putVal(int  hash,  K  key,  V  value,  boolean onlyIfAbsent,  boolean  evict)  {
        Node<K,V>[]  tab;  Node<K,V>  p;  int  n, i;
        // 1.  首次插入时初始化数组
        if ((tab  =  table)  ==  null  ||  (n  =  tab.length)  ==  0)
                n  = (tab  =  resize()).length;
       //  2.  计算桶索引，若桶为空则直接插入
        if ((p =  tab[i  = (n  -  1)  &  hash])  == null)
                tab[i]  =  newNode(hash,  key,  value,  null);
        else  {
                Node<K,V>  e;  K  k;
               // 3.  检查第一个节点是否匹配（优化链表遍历）
                if (p.hash  ==  hash  && ((k  =  p.key)  ==  key  ||  (key  !=  null  &&  key.equals(k))))
                    e =  p;
                //  4.  如果是红黑树节点，调用树插入方法
              else if (p  instanceof  TreeNode)
                        e  = ((TreeNode<K,V>)p).putTreeVal(this,  tab,  hash,  key,  value);
          else  {
                        //  5.  遍历链表
                for  (int binCount  =  0;  ;  ++binCount)  {
                          if  ((e  =  p.next)  ==  null)  {
                              p.next  =  newNode(hash,  key,  value,  null);
                                        if  (binCount  >=  TREEIFY_THRESHOLD  -  1)  //  链表长度≥8时树化
                                treeifyBin(tab,  hash);
                    break;
                                }
                            if (e.hash == hash  &&  ((k = e.key) ==  key  || (key  !=  null  &&  key.equals(k))))
                                      break;
                p  =  e;
                        }
           }
          // 6.  更新已存在的键的值
               if (e !=  null)  {
                        V  oldValue =  e.value;
                        if  (!onlyIfAbsent  ||  oldValue == null)
                                e.value = value;
            afterNodeAccess(e);
                        return  oldValue;
                }
        }
        //  7.  触发扩容检查
        ++modCount;
        if  (++size  >  threshold)
                resize();
        afterNodeInsertion(evict);
        return  null;
}

关键逻辑解析：

1. 首次插入初始化数组：通过 resize() 方法分配初始容量。
2. 快速定位桶位置：(n - 1) & hash 计算索引。
3. 哈希冲突处理：
   • 链表插入：遍历链表到尾部插入新节点。
   • 红黑树插入：当链表长度≥8时触发树化（需满足数组长度≥64，否则优先扩容）。
4. 更新值逻辑：若键已存在，直接覆盖旧值。

---

三、resize 扩容机制

final  Node<K,V>[]  resize() {
    Node<K,V>[]  oldTab  =  table;
       int  oldCap  = (oldTab  ==  null)  ?  0  :  oldTab.length;
        int oldThr  =  threshold;
        int  newCap,  newThr  =  0;
        //  1.  计算新容量和阈值
       if (oldCap >  0)  {
                if (oldCap  >=  MAXIMUM_CAPACITY)  {
                        threshold  =  Integer.MAX_VALUE;
                        return  oldTab;
                }
                else if ((newCap  =  oldCap  << 1)  <  MAXIMUM_CAPACITY  &&  oldCap  >=  DEFAULT_INITIAL_CAPACITY)
                      newThr  =  oldThr  <<  1;  //  容量和阈值均翻倍
       } else if (oldThr  >  0)  //  初始化时指定了容量
              newCap = oldThr;
        else  {  //  默认初始化
                newCap  = DEFAULT_INITIAL_CAPACITY;
                newThr  =  (int)(DEFAULT_LOAD_FACTOR *  DEFAULT_INITIAL_CAPACITY);
        }
        // ...（省略部分阈值计算代码）
        threshold =  newThr;
        Node<K,V>[]  newTab  =  (Node<K,V>[])new  Node[newCap];
        table  =  newTab;
        // 2.  迁移旧数据到新数组
        if (oldTab  !=  null)  {
                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)  //  红黑树拆分
                                ((TreeNode<K,V>)e).split(this,  newTab,  j,  oldCap);
                          else { //  链表拆分
                    Node<K,V>  loHead  =  null,  loTail  =  null;
                           Node<K,V>  hiHead  =  null,  hiTail  =  null;
                                        Node<K,V>  next;
                                        do {
                                                next  =  e.next;
                                 //  判断节点是否留在原位置
                                                if ((e.hash  & oldCap)  ==  0) {
                            if (loTail  ==  null)
                                loHead  =  e;
                            else
                                loTail.next = e;
                            loTail  =  e;
                        } else { //  迁移到新位置（原索引  +  oldCap）
                                                 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;
}

核心逻辑：

1. 容量翻倍：新容量为旧容量的2倍（保证始终是2的幂次方）。
2. 高效迁移：通过 (e.hash & oldCap) == 0 判断节点是否留在原位置或迁移到 原索引 + oldCap，无需重新计算哈希。
3. 链表拆分：避免遍历新数组时链表过长，提升查询效率。

---

四、树化与反树化

//  链表转红黑树（当链表长度≥8且数组长度≥64）
final void  treeifyBin(Node<K,V>[]  tab,  int  hash)  {
        int  n,  index; Node<K,V>  e;
        if  (tab  ==  null  ||  (n  =  tab.length)  <  MIN_TREEIFY_CAPACITY)
                resize();  //  优先扩容而非树化
        else if ((e  =  tab[index  =  (n  -  1)  &  hash]) != null)  {
                //  ...（构建红黑树逻辑）
        }
}

//  红黑树退化为链表（节点数≤6时触发）
final  void  untreeify(HashMap<K,V>  map)  {
        //  ...（替换树节点为链表节点）
}

设计意图：

• 树化阈值（8）：基于泊松分布，哈希冲突达到8的概率极低（约千万分之一）。
• 反树化阈值（6）：避免频繁树化和退化（设置差值防止抖动）。

---

五、源码设计亮点

1. 位运算优化：(n-1) & hash 替代取模运算，提升性能。
2. 延迟初始化：首次插入时才分配内存，减少内存占用。
3. 高低位异或哈希：减少哈希碰撞概率。
4. 扩容迁移策略：利用哈希值高位判断位置，避免重新计算。