JDK1.8 HashMap源码解析

HashMap源码解析

1.hashmap的默认容量为16

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

2.hashmap的最大容量

static final int MAXIMUM_CAPACITY = 1 << 30;

3.hashmap的加载因子

static final float DEFAULT_LOAD_FACTOR = 0.75f;

当hashmap的容量增加到当前容量的3/4时，会触发扩容

4.转为红黑树的阈值

static final int TREEIFY_THRESHOLD = 8;
static final int MIN_TREEIFY_CAPACITY = 64;

当hashmap的某个槽位的链表节点数量达到7时，同时底层数组的长度达到64时，会将链表转为红黑树，如果底层数组长度不足64，将会触发扩容

5.红黑树退化为链表的阈值

static final int UNTREEIFY_THRESHOLD = 6;

如果某个槽位的数据元素个数降低到6个时，并且这个槽位是红黑树结构，那么就会退化为链表结构，退化操作在resize扩容时才会触发

6.获取对象的hash值

static final int hash(Object key) {
        int h;
//        主要是让h的高16位和低16位都参与运行，分散元素在集合中的位置
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

key的hash值决定数据存储位置。

7.hashmap的底层是数组结构

transient Node<K,V>[] table;

通过key的hash计算得到在数组中的位置，然后将数据存储在对应位置的链表或者是红黑树下

 

8.hashmap的实体集合

transient Set<Map.Entry<K,V>> entrySet;

通过实体去遍历map中的元素时，返回的就是这个对象。

9.初始化hashmap对象

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;
  this.threshold = tableSizeFor(initialCapacity);
}
public HashMap(int initialCapacity) {
  this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
  this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

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;
}

可以指定初始容量，以及加载因子，但一般我们都会用默认值，对于初始容量，一般都是2的N次方,如果你传入的不是2的幂次方，tableSizeFor方法会将该数值转为2的幂次方，如：初始化的容量为11，tableSizeFor方法会自动计算出16。

10.初始化hashmap时传入一个map集合

public HashMap(Map<? extends K, ? extends V> m) {
  this.loadFactor = DEFAULT_LOAD_FACTOR;
  putMapEntries(m, false);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
  //获取参数set的大小 
  int s = m.size();
  //如果参数set大于0就添加到指定的set集合中
  if (s > 0) {
    //如果底层的节点数组为null，
    if (table == null) { // pre-size
      //获取初始的容量，如果如果这个初始容量小于最大容量就用这个值，否则就用最大的容量
      float ft = ((float)s / loadFactor) + 1.0F;
      int t = ((ft < (float)MAXIMUM_CAPACITY) ?
               (int)ft : MAXIMUM_CAPACITY);
      //如果这个容量比法治大就扩容
      if (t > threshold)
        threshold = tableSizeFor(t);
    }
    else if (s > threshold)
      resize();
    //循环从参数map中获取数据插入新的map中
    for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
      K key = e.getKey();
      V value = e.getValue();
      putVal(hash(key), key, value, false, evict);
    }
  }
}

先对底层数组进行初始化或者扩容，然后对传入的map进行循环put操作。

 

11.对hashmap执行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) {
  //hashmap的底层数组的声明
  Node<K,V>[] tab;
  //节点表示i位置的节点
  Node<K,V> p;
  //n表示数组的长度，i表示数组的索引
  int n, i;
  //如果底层的table是null，那么就返回一个默认的底层数组，这里直接用扩容函数
  if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;

  //如果没有发生hash碰撞就直接将元素追加到数组中
  if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);

  //如果发生了hash碰撞就需要追加元素到链表上或者红黑树上
  else {
    //            e代表当前的临时节点
    Node<K,V> e; K k;
    //如果对应的位置已经有了元素就直接覆盖
    if (p.hash == hash &&
        ((k = p.key) == key || (key != null && key.equals(k))))
      e = p;


    //如果当前的节点已经是红黑树的节点那么就插入红黑树的节点
    else if (p instanceof TreeNode)
      e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

    //            追加链表或者转为红黑树
    else {
      //如果hashmap中的索引相同但是key值不同时，将新的节点放在链表的尾部
      //如果在变量链表的过程中包含了key值，那么就直接覆盖
      for (int binCount = 0; ; ++binCount) {
        //                    一直循环链表，知道链表的最后一个元素然后追加信息节点，然后去判断这个链表上有八个节点时就转为红黑树
        if ((e = p.next) == null) {
          p.next = newNode(hash, key, value, null);
          //如果链表的节点数量大于等于8时转为红黑树的结构
          if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
            //                            转换成红黑树
            treeifyBin(tab, hash);
          break;
        }
        //                    如果说元素重复的话就不添加了
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
          break;
        //                    一直访问链表的下一个元素
        p = e;
      }
    }
    //如果这是个覆盖key的操作而不是插入操作，就返回旧的值
    if (e != null) { // existing mapping for key
      V oldValue = e.value;
      if (!onlyIfAbsent || oldValue == null)
        e.value = value;
      afterNodeAccess(e);
      return oldValue;
    }
  }
  ++modCount;
  if (++size > threshold)
    resize();
  afterNodeInsertion(evict);
  return null;
}

1.因为hashmap的底层有数组结构，所以首先要完成数组的初始化操作。而数组的初始化操作一般在resize这个扩容操作中完成。

2.当我们在执行putVal操作时，首先通过hash算法得到数组存在在数组中的位置，如果这个位置为空，就创建一个node节点，将数据放入数组，如果数组的位置元素并不为空，那么进行往链表或者红黑树中添加元素，或者正好链表转红黑树的操作。

3.当我们向数组的指定位置追加元素时，首先声明了一个临时节点e，第一个判断表示参数传入的key所定位到的位置有数据，并且还有相同的key，这时候执行的是hashmap的put覆盖操作。

4.如果说put操作定位的位置返回的是红黑树的节点，那么就向红黑树添加新的元素

5.第三中情况就是我们向链表中追加元素，而这个链表是个单向的链表。

6.当新加入的元素使链表达到7个元素时，这个链表就要转为红黑树，但是如果在链表中找到了重复的key，此时就直接跳出循环，因为我们只是普通的put操作，所以在跳出循环后onlyIfAbsent=false，会将value进行覆盖操作，但是如果onlyIfAbsent=true，表示map中已存在key，就不会更新数据

7.当然，如果是添加不同的元素，还是要对集合的大小加1并且判断是否需要扩容，这里可以看出扩容是在加入元素之后就执行的操作。

8.当触发链表转红黑树的操作时，并不一定会转为红黑树，还有一个条件就是底层数组的长度要大于64，否则此时触发的是扩容，而不是转为红黑树。

 

12.获取数组中的元素

public V get(Object key) {
  Node<K,V> e;
  //        通过key的hashcode与key查询值，首先是获得在数组中位置，如果该位置就是查找的元素，直接返回
  //        如果不是就判断数据结构如果是树结构就用树的查询方法去查，
  //        如果是链表就循环链表去比对
  return (e = getNode(hash(key), key)) == null ? null : e.value;
}
 final Node<K,V> getNode(int hash, Object key) {
   //底层节点数组
   Node<K,V>[] tab;
   Node<K,V> first, e;
   //底层节点数组的长度
   int n;
   K k;
   //如果底层数组不为空，并且节点不为空
   if ((tab = table) != null && (n = tab.length) > 0 &&
       //                首节点不等于空
       (first = tab[(n - 1) & hash]) != null) {

     //判断first节点是不是要查找的节点
     if (first.hash == hash && // always check first node
         ((k = first.key) == key || (key != null && key.equals(k))))
       return first;

     if ((e = first.next) != null) {
       if (first instanceof TreeNode)
         return ((TreeNode<K,V>)first).getTreeNode(hash, key);
       do {
         if (e.hash == hash &&
             ((k = e.key) == key || (key != null && key.equals(k))))
           return e;
       } while ((e = e.next) != null);
     }
   }
   return null;
 }

参数key要进行hash运算，获取hash值定位元素在底层数组的位置，如果底层数组为空，或者数组长度为0或者指定位置的元素为空，这些都将返回null对象，

否则如果链表或者红黑树的第一个元素的hash值就是我们要找的数据就直接返回，否则就判断返回的节点是链表节点还是红黑树节点，如果是红黑树，就通过红黑树的方法去查，否则就遍历链表

13.hashmap的扩容操作

   final Node<K,V>[] resize() {
        //将全局的底层节点数组放入新的方法内的节点数组中
        Node<K,V>[] oldTab = table;
        //获取旧的数组容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //获取旧的阈值
        int oldThr = threshold;
        //初始新的容量和阈值
        int newCap, newThr = 0;
        //如果旧的容量大于0,判断旧的容量是否大于hashmap的最大容量，如果大于则设置阈值为int的最大值，并返回旧的数组
        //如果旧的容量的二倍小于hashmap的最大值并且旧的容量比默认的容量要大，那么新的阈值扩展为原来的2倍
        //如果旧的阈值大于0，那么新的容量就是就的阈值
        //否则新的容量就是默认的容量，新的阈值就是默认的加载因子乘以默认的容量
        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; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //如果新的阈值等于0，表示这个是一个空表，并且旧的阈值大于0
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        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 { // preserve order
                        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 {
                                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;
    }

在进行扩容之前，先获得底层数组的长度，此处底层可能还是个空数组，对于向空数组中添加元素也要先扩容，再添加元素

处理扩容有多种情况，第一，底层并不是空数组，此时如果数组的长度已经大于等于支持的最大容量了将不会执行扩容操作。

如果扩容后的容量超过了hashmap支持的最大容量，会设置一个新的阈值，这个阈值是容量值乘以加载因子。然后将之前hashmap底层的数组复制到新的数组下，如果数组元素不是链表，就直接赋值，如果槽的节点是红黑树，就进行红黑树的处理，

如果槽点是链表，需要进行额外处理，而并不是把这个链表全部直接移动到另一个数组的槽位上，而是要对链表中的数据进行循环遍历，然后将链表数据分为两个链表，一个链表的所以位置不变，另一个链表的索引位置是j + oldCap，并且其他槽位的数据在拆分为两个链表时也不会与之前的冲突

 

写在最后的话：

第一次写技术博客，写的不好请大家见谅，有错误之处还请大家指正。语言比较接地气，我觉得还是比较容易理解的。