HashMap源码分析

HashMap源码分析

@author lisiwen

@createTime 2020/06/10

1. HashMap类的继承关系

​ 可以看到HashMap继承自AbstractMap，实现了Serializable和Cloneable。这里介绍AbstractMap的源码，因为阅读之后发现比较简单，有兴趣的可以自行去看看，其中的keyset()和values()方法与HashMap中的类似。Serializable接口表示HashMap实现了的序列化，Cloneable接口表示可以合法的调用clone()，如果不实现该接口而调用clone，会报CloneNotSupportedException。

2. HashMap成员变量

//默认初始化map的容量：16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//map的最大容量：2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的填充因子：0.75，能较好的平衡时间与空间的消耗
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//将链表(桶)转化成红黑树的临界值
static final int TREEIFY_THRESHOLD = 8;
//将红黑树转成链表(桶)的临界值
static final int UNTREEIFY_THRESHOLD = 6;
//转变成树的table的最小容量，小于该值则不会进行树化
static final int MIN_TREEIFY_CAPACITY = 64;
//上图所示的数组，长度总是2的幂次
transient Node<K,V>[] table;
//map中的键值对集合
transient Set<Map.Entry<K,V>> entrySet;
//map中键值对的数量
transient int size;
//用于统计map修改次数的计数器，用于fail-fast抛出ConcurrentModificationException
transient int modCount;
//大于该阈值，则重新进行扩容，threshold = capacity(table.length) * load factor
int threshold;
//填充因子
final float loadFactor;

可以看到，hashMap是使用node节点数组形式存放数据的，结构比较简单，

static class Node<K,V> implements Map.Entry<K,V> {
   
  // key & value 的 hash值
  final int hash;
  final K key;
  V value;
  //指向下一个节点
  Node<K,V> next;

  Node(int hash, K key, V value, Node<K,V> next) {
   
    this.hash = hash;
    this.key = key;
    this.value = value;
    this.next = next;
  }

  public final K getKey()        {
    return key; }
  public final V getValue()      {
    return value; }
  public final String toString() {
    return key + "=" + value; }

  public final int hashCode() {
   
    return Objects.hashCode(key) ^ Objects.hashCode(value);
  }

  public final V setValue(V newValue) {
   
    V oldValue = value;
    value = newValue;
    return oldValue;
  }

  public final boolean equals(Object o) {
   
    if (o == this)
      return true;
    if (o instanceof Map.Entry) {
   
      Map.Entry<?,?> e = (Map.Entry<?,?>)o;
      if (Objects.equals(key, e.getKey()) &&
          Objects.equals(value, e.getValue()))
        return true;
    }
    return false;
  }
}

3.构造函数

3.1 无参数构造函数

public HashMap() {
   
  //其他成员变量也都是默认的
  this.loadFactor = DEFAULT_LOAD_FACTOR;
}

3.2 传初始化容量（建议如果知道要使用的map容量，都使用这种）

public HashMap(int initialCapacity) {
   
  this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

3.3 传初始化容量以及填充因子

public HashMap(int initialCapacity, float loadFactor) {
   
  if (initialCapacity < 0)
    throw new IllegalArgumentException("Illegal initial capacity: " +
                                       initialCapacity);
  if (initialCapacity > MAXIMUM_CAPACITY)
    initialCapacity = MAXIMUM_CAPACITY;
  if (loadFactor <= 0 || Float.isNaN(loadFactor))
    throw new IllegalArgumentException("Illegal load factor: " +
                                       loadFactor);
  this.loadFactor = loadFactor;
  //tableSizeFor()是用来将初始化容量转化大于输入参数且最近的2的整数次幂的数，比如initialCapacity = 7，那么转化后就是8。
  this.threshold = tableSizeFor(initialCapacity);
}

tableSizeFor()，将初始化容量转化大于或等于最接近输入参数的2的整数次幂的数:

static final int tableSizeFor(int cap) {
   
  int n = cap - 1;
  n |= n >>> 1;
  n |= n >>> 2;
  n |= n >>> 4;
  n |= n >>> 8;
  n |= n >>> 16;
  return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

|是或运算符，比如说0100 | 0011 = 0111，>>>是无符号右移，忽略符号位，空位都以0补齐，比如说0100 >>> 2 = 0001，现在来说一下这么做的目的：

首先>>>和|的操作的目的就是把n从最高位的1以下都填充为1，以010011为例，010011 >>> 1 = 001001，然后001001 | 010011 = 011011，然后再把011011无符号右移两位：011011 >>> 2 = 000110，然后000110 | 011011 = 011111，后面的4、8、16计算过程就都省去了，int类型为32位，所以计算到16就全部结束了，最终得到的就是最高位及其以下的都为1，这样就能保证得到的结果肯定大于或等于原来的n且为奇数，最后再加上1，那么肯定是：大于且最接近输入值的2的整数次幂的数。

那么为什么要先cap - 1呢，我们可以先思考以下，如果传进来的本身就是2的整数幂次，比如说01000，10进制是8，那么如果不减，得到的结果就是16，显然不对。所以先减1的目的是cap如果恰好是2的整数次幂，那么返回的也是本身。

合起来得到这个tableSizeFor()方法的目的：返回大于或等于最接近输入参数的2的整数次幂的数。另外，笔者特意回去看了JDK1.7的源码，发现1.7用的是roundUpToPowerOf2()方法，里面用到里了>>以及减操作，性能上来说肯定还1.8的高。

3.4 传map转化为HashMap的构造函数