HashMap添加数据

HashMap:哈希表通过建立「键 key」与「值 value」之间的映射，实现高效的元素查询。具体而言，我们向哈希表输入一个 key，则可以在 O(1) 时间内获取对应的 value 。

在不产生哈希冲突的情况下，HashMap的增删改查时间复杂度都是O(1)，具体原因看后面原理分析。

哈希冲突：不同的key通过相同的哈希函数计算出相同的哈希地址，即多个key存入同一个Node<K,V>[] table中

解决哈希冲突：

1.扩容哈希表：扩容阈值（容量*负载系数0.75）

key数量不变的情况下，哈希表越大：key与哈希表取余的值越大，多个key出现相同的的哈希值概率越小

2.优化哈希表：链式寻址（冲突合并成链表），开放寻址（哈希值不一定是存储元素的地址）

java采用哈希表扩容+链式寻址解决哈希冲突

HashMap添加元素源码分析

public class HashMap<K,V> ...{
    
    transient Node<K,V>[] table; //HashMap存储数据的容器，也称为Hash桶
    
    //The bin count threshold for using a tree rather than list for a bin.
    //使用树而不是列表作为存储箱的存储箱计数阈值。即链表转为红黑树
    static final int TREEIFY_THRESHOLD = 8;
    
     
    //The default initial capacity - MUST be a power of two.
    //默认的初始容量-必须是二的幂。
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 位移运算 = 10000 = 16
    
    //The number of key-value mappings contained in this map.
    //此映射中包含的键值映射的数量。
    transient int size;
    
    //The load factor used when none specified in constructor.
    //在构造函数中未指定时使用的负载系数。
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    
    //The next size value at which to resize (capacity * load factor).
    //要调整大小的下一个大小值（容量*负载系数）。即扩容阈值
    int threshold;
    
    public V put(K key, V value) {
        return putVal(hash(key), key, value,...); //hash值8位16进制
    }
    
	final V putVal(int hash, K key, V value,...) {
    	Node<K,V>[] tab; //hashMap存储数的容器
    	Node<K,V> p; //数据以Node格式存储
    	int n, i; 
    
        //tab hash表 n=hash表长度(第一次添加元素为16)
    	if ((tab = table) == null || (n = tab.length) == 0){
       	 n = (tab = resize()).length; //如果第一次添加元素，扩容hash表
    	}
        //p=当前元素的存储下标里的第一个元素 i=当前元素存储下标
        if ((p = tab[i = (n - 1) & hash]) == null){
            //计算出当前元素存储位置，判断位置是否为空，空则直接存入
            tab[i] = newNode(hash, key, value, null); 
        }else{
            //执行到这里代表hash表不为空，且当前元素存储的hash表下标也不为空
            
            //判断当前元素存储的下标的第一个元素hash值 是否与当前元素的hash值相等 && 值是否相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k)))){
                e = p; //相等则直接覆盖值，添加操作完成
            }
            ...
            else {
                //执行到这里代表当前元素存储的hash表下标不为空，且第一个元素不等于当前存入元素
                for (int binCount = 0; ; ++binCount) {
                    //e= p的下一个指向的元素
                    if ((e = p.next) == null) {
                        //如果p的下一个元素为空则直接把元素存入到p的下一个元素
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1){
                    //当前下标存储元素超过8个之后，将当前下标的元素存储结构由单向链表转为红黑树
                            treeifyBin(tab, hash);
                        }                            
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k)))){
                        //p的下一个元素不为空，并且hash值一致，值也一致则跳出循环
                        break;
                    }                        
                    p = e;
                } 
                
            
        }
        if (++size > threshold){
            //当前存储元素的总数量>负载阈值，则触发Hash表扩容
            resize();  
        }
}            

总结：

1.第一次添加时触发hash表扩容，默认扩容大小16

2.计算key的hash值，用hash表长度&元素hash值计算出元素存储的位置，判断当前位置是否为空，存储位置为空则以Node格式直接存入

3.存储位置不为空则遍历存储位置的所有元素hash值和调用元素的equals()方法判断元素是否相等，相等则覆盖，不相等则链接到链表的末尾

4.当链表长度>8时调用treeifyBin()方法将链表转成红黑树