HashMap源代码详解

HashMap类声明

HashMap类声明如下：

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
   
  //……
  //……
}

从定义中可以看出，哈希表是支持克隆、序列化的。

HashMap继承了AbstractMap，除了toString方法，HashMap重写了其他所有的AbstractMap方法。

HashMap实现的克隆是浅复制。

HashMap自定义了序列化相关的方法。

HashMap实现原理

分析HashMap代码之前先了解它的实现原理，HashMap是通过拉链法实现的，何谓拉链法？HashMap是一个数组，数组的元素是一个链表，键值对是存储在该链表中的。通过这种方法能够解决哈希冲突问题，哈希码相同的键对应的键值对会存储在同一个链表中。拉链表示例图如下：

该哈希表的容量为8，键值对数量为6。目前该哈希表中只有索引0、4、7处有数据。其中e0和e1节点键的哈希码相同，e3、e4、e5节点键的哈希码相同。

HashMap中有加载因子的概念，它代表了哈希表有多满的一种程度，这个值默认是0.75。当哈希表的键值对数量大于等于加载因子和哈希表容量乘积的时候，将会触发重哈希。例如，上图哈希表重哈希的键值对数量临界值为6（8*0.75=6）。因为该哈希表键值对数量已经为6，此时若继续往该哈希表添加键值对，将会触发重哈希。

加载因子是为了哈希表的效率而提出的，这会保证哈希表中的链表不至于太长，从而减少冲突，增加查询效率。平均来说，哈希表中每个链表长度都将小于1，因此查找效率非常高。加载因子越大，冲突的可能性就越大，加载因子越小，冲突的可能性就越小。

有了实现原理的基本了解，接下来分析HashMap的源码实现。

HashMap源码分析

成员变量

HashMap包括了很多成员变量，下面代码详细注释了每个字段的含意：

    //哈希表的默认容量是16
    //注意：哈希表容量必须是2的n次幂，这是为了更快的定位哈希索引
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
    //哈希表的最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //哈希表的加载因子默认值0.75
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //若没有对哈希表执行任何操作，数组是一个空值，只有在需要的时候才会去分配内存
    static final Entry<?,?>[] EMPTY_TABLE = {};
    //哈希表的数组，其中每个元素都是一个链表，哈希表数组大小必须是2的n次幂
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
    //哈希表的键值对数量
    transient int size;
    //哈希表扩容的临界值，大小等于加载因子*哈希表的容量
    int threshold;
    //加载因子
    final float loadFactor;
    //哈希表结构性改变的次数，结构性改变指的是改变了哈希表键值对数量
    //该字段主要用在迭代器的快速失败策略(fail-fast)，后面还会说明
    transient int modCount;
    //默认扩容的临界值
    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
    //一个随机的值，用于计算key的哈希值
    transient int hashSeed = 0;
    //键值对的Set
    private transient Set<Map.Entry<K,V>> entrySet = null;

Holder静态内部类

//HashMap的静态内部类，主要是去获取jdk内置的扩容临界值
private static class Holder {
   

    static final int ALTERNATIVE_HASHING_THRESHOLD;

    static {
      //取jdk内置的扩容临界值
      String altThreshold = java.security.AccessController.doPrivileged(
        new sun.security.action.GetPropertyAction(
          "jdk.map.althashing.threshold"));

      int threshold;
      try {
        threshold = (null != altThreshold)
          ? Integer.parseInt(altThreshold)
          : ALTERNATIVE_HASHING_THRESHOLD_DEFAULT;

        // disable alternative hashing if -1
        if (threshold == -1) {
          threshold = Integer.MAX_VALUE;
        }

        if (threshold < 0) {
          throw new IllegalArgumentException("value must be positive integer.");
        }
      } catch(IllegalArgumentException failed) {
        throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed);
      }

      ALTERNATIVE_HASHING_THRESHOLD = threshold;
    }
}

构造函数

//包含初始容易和加载因子的构造函数
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
      throw new IllegalArgumentException("Illegal initial capacity: " +
                                         initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
      //HashMap的容量不能大于MAXMUM_CAPACITY
      initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
      throw new IllegalArgumentException("Illegal load factor: " +
                                         loadFactor);
    this.loadFactor = loadFactor;
    threshold = initialCapacity;
    //HashMap的init方法其实是个空方法
    init();
}

//根据指定初始容量、默认加载因子创建一个空的HashMap
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//根据默认容量和默认加载因子创建一个空的HashMap
public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//根据指定的HashMap创建一个新的HashMap，新的HashMap将拥有指定HashMap所有的键值对。
//新HashMap的初始容量根据指定HashMap的键值对数量决定，加载因子取默认值
public HashMap(Map<? extends K, ? extends V> m) {
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
    //创建好空的HashMap后，根据扩容临界值扩容该HashMap
    inflateTable(threshold);
    //将指定哈希表m的所有键值对添加到该哈希表中
    putAllForCreate(m);
}

扩容方法

//大于等于number的第一个2的n次幂的值，这个保证了哈希表的容量是2的n次幂
private static int roundUpToPowerOf2(int number) {
    return number >= MAXIMUM_CAPACITY
      ? MAXIMUM_CAPACITY
      : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}

//扩容哈希表
private void inflateTable(int toSize) {
    int capacity = roundUpToPowerOf2(toSize);

    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    //初始化哈希种子
    initHashSeedAsNeeded(capacity);
}

Integer.highestOneBit方法

上面代码片断使用了Integer.highestOneBit方法，这片代码挺有意思的，看下源码实现：

public static int highestOneBit(int i) {
    i |= (i >>  1);
    i |= (i >>  2);
    i |= (i >>  4);
    i |= (i &