当添加一个键值对元素时，HashMap发生了什么？

首先，我们得了解HashMap底层是如何存储数据的，它是如何添加元素的。

HashMap 内部数据结构使用数组+链表+红黑树进行存储。数组类型为 Node[]，每个Node 都保存了某个KV键值对元素的 key 、 value、hash、next 等值。由于next 的存在，所以每个Node对象都是一个单向链表中的组成节点。
当新添加一个KV键值对元素时，通过该元素的 key的 hash 值，计算该元素在数组中应该保存的下标位置。如果该下标位置如果已经存在其它Node 对象(产生哈希冲突)，则采用链地址法处理，即将新添加的KV键值对元素将以链表形式存储。将新元素封装成一个新的Node 对象，插入到该下标位置的链表尾部(尾插法)。当链表的长度超过 8并目数组长度大干64 时，为了避免查找搜索性能下降，该链表会转换成一个红黑树。

如图所示:

 HashMap的数据结构定义:

public class HashMap{
    // 每个Node既保存一个KV键值对，同时也是链表中的一个节点
    Node<K,V>[] table; 
}

public class HashMap{
    // ...
    
    // 静态内部类Node
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash; // 哈希值
        final K key; // 键
        V value; // 值
        Node<K,V> next; // 下一个节点(由于只拥有next，所以该链表为单向链表)
    }
    // ...
}

然后我们来了解下HashMap的hash函数，HashMap初始容量，HashMap扩容，什么时候扩容?

HashMap的hash函数:
HashMap 通过新添加元素 key的 hashCode()方法，计算一个hash值，然后通过这个hash值计算位置下标。

static final int hash(Object key) {
    int h;
    // 通过key的hashCode()方法返回的哈希值与它的高16位进行异或运算
    // 作用：计算出的hash值，在计算下标位置时，会更“散列”，减少哈希冲突
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

HashMap初始容量：
首先HashMap 初始化时，默认的数组大小只有 16 ，通过位运算 1<<4 计算得出。并且，数组的长度必须为2”(MUST be a powerof two)，因为数组长度为2的n次幂时，可以使用&与位运算，结合hash值，快速计算该元素在数组中的下标位置，提高 HashMap 的使用效率。

添加时，通过key的hash 值，使用&按位与位运算，计算该元素在数组中的下标。作用等同于hash %数组长度 

int index = (数组长度 - 1) & key的hash值

由干计算机底层进行取模运算时，分为两步，第一步求商，即c=a/b:第二步求余数，即r=a-c*b，这两步包含了除法，乘法和减法运算，所以效率不高，使用位运算，计算结果相同，并且效率高。前提是，数组容量必须为2的n次幂。

HashMap扩容
HashMap 底层采用数组+链表+红黑树，扩容过程中需要按照数组容量和加载因子来进行判断。
数组容量:基础数组Node<K，v>[l table的长度。如果没有指定容量，添加第一个元素时，该数组按照默认值 16 进行初始化

加载因子:用来表示 HashMan 集合中元素的埴满程度，默认为 0.75f，越大则表示允许埴满的元素就越多，集合的空间利用率就越
高，但是冲突的机会增加。反之，越小则冲突的机会就会越少，但是空间很多就浪费。

public class HashMap{
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
}

什么时候扩容?
HashMap 的扩容方法是 resize()方法，发生下列两种情况时，会发生扩容:
情况1:HashMap中的元素个数超过扩容阈值 threshold时，就会进行数组扩容(扩容阈值threshold =数组容量x加载因子)。例如:加载因子(LoadFactor)的默认值为0.75f，数组容量默认为16，当HashMap 中元素个数超过 16x0.75=12的时候，数组就会扩容。
情况2:HashMap 加入新元素时，如果链表长度大干8时，会将当前链表转换为红黑树。在转换红里树之前，会判断数组长度，如果
小于64，会产生数组扩容。如果数组长度大于64，才会将链表转换为红黑树。(链表属于线性查找，速度慢)

// 添加新元素 
final V putVal(int hash, K key, V value) {
     //...
     
     // 判断当前集合中的元素数量，是否超过阈值threshold
     if (++size > threshold)
            resize(); // 数组扩容
     //...
}

// 链表转换为红黑树
final void treeifyBin(Node<K,V>[] tab, int hash) {
    //...
    // 数组为空或者数组的长度n小于64
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize(); // 数组扩容
    // ...
}

public class HashMap{
   // 默认链表长度 
   static final int TREEIFY_THRESHOLD = 8;
    
   // 添加键值对的方法
   final V putVal(int hash, K key, V value){
        //...
        
        // 将key和value，插入链表尾部
        // 循环时，使用binCount进行计数
        for (int binCount = 0; ; ++binCount) {
            // 判断节点p的next是否空
            if ((e = p.next) == null) {
                // 插入链表尾部
                p.next = newNode(hash, key, value, null);
                
                // 判断链表数量是否大于8
                if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                    // 链表长度超过8，将当前链表转换为红黑树
                    treeifyBin(tab, hash);
                break;
            }
        }
    }
    
    // 转换为红黑树
    final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        // 数组长度如果小于64，则优先扩容数组
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            // 遍历链表节点，转换为红黑树
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }
}

HashMap 每次扩容时，会按照当前数组的容量扩容2倍。例如:当前数组容量为16，当HashMap 中元素个数超过16x0.75=12 的时候，数组就会扩容 2 倍