HashMap底层原理

HashMap底层原理

idea源码图标规则

c - class

m - method

1. 构造方法 - 与类名一样

2. 成员方法 : 方法名 + 形参 + 返回值类型

   2.1 向上箭头: 表示重写 父类 或者 接口 的方法

   2.2 向右的箭头: 继承 下来的方法 (来自于接口或者类)

f - field

i - interface

class带锁: 该类的内部类

1.HashMap的属性

链表Node

int hash 哈希值

K key 键

V value 值

Node<K,V> next 下一个节点地址值

红黑树TreeNode

int hash 哈希值

K key 键

V value 值

TreeNode parent 父节点地址

TreeNode left 左子节点地址

TreeNode right 右子节点地址

prev (暂时用不到)

boolean red 节点颜色

底层数组 table

数组长度 capacity 默认长度16

加载因子 load factor = 0.75F

最大容量 max_capacity 1<<30 == 2的30次方

构造方法

无参构造: 做了一件事 - loadFactor = 加载因子

方法

put方法: 返回putVal(hash,key,value,onlyIfAbsent,evict)方法 - key.hashCode()

1.  hash方法计算哈希值
2.  onlyIfAbsent: false --  覆盖数据 / true -- 不覆盖 

2. 具体源码分析

new HashMap<> ();

//链表中的键值对对象

//Node<K,V>[] table   哈希表中数组的名字

//DEFAULT_INITIAL_CAPACITY	数组默认长度16

//DEFAULT_LOAD_FACTOR	默认加载因子0.75


// 常见HashMap对象
HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa" , 111);
hm.put("bbb" , 222);
hm.put("ccc" , 333);
hm.put("ddd" , 444);
hm.put("eee" , 555);



//参数1 : 键
//参数2 : 值

//返回值 : 被覆盖元素的值,没有覆盖则返回null
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

//利用键计算出对应的哈希值,对哈希值做额外处理
//简单理解 : 返回键的哈希值
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

//参数 : 哈希值 , 键 , 值 键重复是否保留(true/false)
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
	    //局部变量 - 记录哈希表数组的地址值,效率更高
    	//成员变量定义在堆里面,方法运行在 栈内存中
        Node<K,V>[] tab;
		
		//临时的第三方变量,记录键值对对象的地址值
        Node<K,V> p;
        
		//表示当前数组长度
		int n;
		
		//索引
        int i;
		
		//table是成员变量哈希表中数组的地址值
		tab = table;

        if (tab == null || (n = tab.length) == 0){
			//1.第一次添加,创建长度16,加载因子为0.75的数组
            //2.不是第一次添加的时候,会看数组中的元素是否达到了扩容的条件
            //如果没有达到扩容条件,底层不会做任何操作
            //若果达到了扩容条件,底层会把数组扩容为原来的两倍,并且把数据全部转移到新的哈希表中
			tab = resize();
			//把当前数组的长度赋值给n
			n = tab.length;
        }

		//数组长度与hash值进行计算,计算出当前键值对对象,在数组中应该存入的位置
		i = (n - 1) & hash; //index
		//获取数组中对应元素的数据
		p = tab[i];
		
    	
        if (p == null){
			//创建一个键值对对象,直接添加到数组当中
            tab[i] = newNode(hash, key, value, null);
        }else {
			Node<K,V> e;
			K k;
			
            //等号的左边: 数组中键值对的哈希值
            //等号的右边: 当前要添加的键值对的哈希值
            //如果键不一样,返回false
            //如果键一样,则返回true
			boolean b1 = p.hash == hash;
			
            if (b1 && (  (k = p.key) == key || (key != null && key.equals(k)))  ){
                e = p;
            } else if (p instanceof TreeNode){
                //判断数组中获取出来的键值对是不是红黑树中的节点
                //如果是,则调用方法putTreeVal,按照红黑树规则添加到树种
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            } else {
                //如果不是红黑树中的节点,则下面挂的是链表
                //判断条件不写,默认是true
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
						//创建一个新的节点,挂在下面形成链表
                        p.next = newNode(hash, key, value, null);
						//判断当前链表长度是否超过8,如果是
						//treetreeifyBin还会判断数组长度是否大于等于64
                          //同事满足这两个调节就会把链表转成红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1)
                            treeifyBin(tab, hash);
                        break;
                    }
					//利用 哈希值 判断键值是否一样
                      //如果哈希值一样,为防止 哈希碰撞(低概率),就会调用equals方法比较内部的属性值是否相同
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))){
                        //方法体只有一行,大括号可以不写
						 break;
					}
					//p记录要对比的对象地址
                    p = e;
                }
            }
			
			//如果e为null,则表示当前不需要覆盖任何元素
			//如果e不为null,表示当前的键是一样的,值才会被覆盖
            if (e != null) {
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null){
					
					//等号的右边: 要添加的值
                      //等号的左边: 覆盖 键 相同的位置的 value值 (false表示老元素不保留)
					e.value = value;
				}
                afterNodeAccess(e);
                return oldValue;
            }
        }
		
        //threshold: 记录数组长度 * 0.75 ,哈希表的扩容时机
        if (++size > threshold){
			 resize();
		}
        
		//表示没有覆盖任何元素
        return null;
    }