HashMap底层机制和源码剖析

HashMap底层机制：

1. 目录

   HashMap底层机制：

   源码剖析

   1、执行构造器

   2、执行put

   （1）哈希值计算

   （2）putVal方法：

   1）代码注释

   2）resize()方法

   3）Node

     (3)流程图

   （4）总结：

   ---

   HashMap底层维护了Node类型的数组table，默认为null
2. 当创建对象时，将加载因子初始化为0.75
3. 当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，判断该元素的key和准备加入的key是否相等，如果相等，则直接替换为val；如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。
4. 扩容：第一次添加，则需要扩容table容量为16，临界值（threshold）为12（16*加载因子）。当添加的元素达到12，就会扩容到16*2=32，新的临界值32*0.75=24，依次类推。
5. 在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD（默认为8），而且table大小>=MIN_TREEIFY_CAPACITY（默认为64）就会进行树化（红黑树），否则仍然采用数组扩容机制。

源码剖析

测试：首先我们输入以下代码

public class Main {
    public static void main(String[] args) {
        HashMap map=new HashMap();
        map.put("sanguo",45);
        map.put("xiyou",30);
        map.put("sanguo",40);
        System.out.println("map="+map);
    }
}

输出结果

map={xiyou=30, sanguo=40}

然后我们debug源码，看看为什么会得到这样的输出

1、执行构造器

执行构造器：new HashMap()，初始化加载因子为0.75

HashMap map=new HashMap();

Step Into进入后：

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

static final float DEFAULT_LOAD_FACTOR = 0.75f;

2、执行put

 map.put("sanguo",45);

Step Into： 

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

（1）哈希值计算

通过hash(key)，来看一下 hash 方法的源码，该方法的作用是：将 key 的 hashCode 值进行处理，得到最终的哈希值。

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

对于该方法的具体解释，请看另外一篇文章：HashMap的哈希/扰动函数的设计，为什么能降低hash碰撞？-CSDN博客

（2）putVal方法：

1）代码注释

在方法上添加了注释，先了解一下代码的内容

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;//定义辅助变量
        //tab是HashMap的一个数组，类型是Node[]。
        //if语句表示如果当前table是null，或者大小=0，就进行第一次扩容。
        //扩容到16个空间
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
       //根据key得到hash,计算该key应该放到table的哪个位置,并把这个位置的对象，赋给p
        if ((p = tab[i = (n - 1) & hash]) == null)
         如果p为null，表示还没有存放元素，就会创建一个Node，放到table中索引为i的位置
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;//创建的辅助变量
        //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样，
        //并且满足以下两个条件之一：
       //准备加入的key和p指向的Node节点的key是同一个对象
      //p指向的Node节点的key的equals()和准备加入的key比较后相同。就放弃添加对象
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
         //再判断p是不是一颗红黑树，
         //如果是一颗红黑树，就调用putTreeVal添加
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
        //如果table对应索引位置，已经是一个链表，就使用for循环比较
                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
        //注意：在进行树化时，要进行判断： 
        // if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY（64）)
           // resize();
            //如果上面条件成立，先进行table扩容，条件不成立时，转换成红黑树
                           treeifyBin(tab, hash);
                        break;
                    }
           //依次和该链表的每一个元素比较过程中，如果有相同情况，就直接break
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;//替换key对应的value
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;//增加修改次数
        if (++size > threshold)//增加哈希表的大小，并在达到阈值时进行扩容操作。
            resize();
        afterNodeInsertion(evict);//在插入节点后可能会执行一些逻辑
        return null;//返回null，表示插入操作完成。
    }

2）resize()方法

接着看一下这段代码使用的resize()方法：

final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; // 将哈希表的旧数组赋值给oldTab变量
int oldCap = (oldTab == null) ? 0 : oldTab.length; // 计算旧数组的长度作为旧容量
int oldThr = threshold; // 将旧的阈值（threshold）赋值给oldThr变量
int newCap, newThr = 0; // 定义新容量和新阈值，初始值为0

if (oldCap > 0) { // 如果旧容量大于0，说明哈希表已经初始化过
    if (oldCap >= MAXIMUM_CAPACITY) { // 如果旧容量大于等于最大容量（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) { // 如果旧阈值大于0，说明旧容量是通过阈值设置的
    newCap = oldThr; // 将新容量设为旧阈值
} else { // 如果旧容量和旧阈值都为0
    newCap = DEFAULT_INITIAL_CAPACITY; // 将新容量设为默认初始容量
    newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 将新阈值设为默认加载因子乘以默认初始容量的整数值
}

if (newThr == 0) { // 如果新阈值仍然为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]; // 创建新的哈希表数组，将其赋值给newTab变量
table = newTab; // 将哈希表的数组引用指向新创建的数组，完成扩容操作

3）Node

再了解一下Node:可以看到Node 的属性。

 static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

  (3)流程图

我们用流程图总结一下HashMap put过程

（4）总结：

1. 首先进行哈希值的扰动，获取⼀个新的哈希值。
2. 判断tab是否位空或者长度为0，如果是则进行扩容操作。
3. 根据哈希值计算下标，如果对应下标正好没有存放数据，则直接插入即可否则需要覆盖。 tab[ i = ( n - 1 ) & hash ] )
4. 判断tab[i]是否为树节点，否则向链表中插入数据，是则向树中插入节点。
5. 如果链表中插入节点的时候，链表长度大于等于8，则需要把链表转换为红黑树。
6. 最后所有元素处理完成后，判断是否超过阈值,超过则扩容。

有兴趣的伙伴可以自己debug一下，追一下put的过程。