HashMap是如何实现的(底层原理)?

HashMap底层原理

• 简述
          HashMap是Java开发过程中使用最多的集合之一,其中的put(key,value)和get(key)方法,是我们在使用HashMap时最常使用的方法,但是底层的原理我们可能就了解得比较少了,或许你知道HashMap是使用hash算法,然后基于数组+链表+红黑树来实现的,或许还知道HashMap内部数组的初始长度为16,并且还能自动扩容.今天我们就来探究一下put(key,value)和get(key)这两个常用的方法的实现过程和原理.

• put(key,value)的原理
        首先我们调用put方法的时候,方法内部会调用hash(key)方法,计算出key的hash值h,然后通过HashMap的主干部分(数组tab)的长度length来进行位与运算(length-1)&h得出一个index=(length-1)&h值,然后直接根据index的值,将Node对象放入对应的tab[index]=Node即可,如下面伪代码和图所示:

		HashMap mapDemo=new HashMap()
		mapDemo.put("name","Aiden")时,
		Node node=new Node("name","Aiden");
		int index=hash("name")&length-1,假如算出index=2
		tab[2]=node;

      虽然在计算index的时候采用的是均匀分布算法,但是当put的key-value越来越多时,不可避免的会出现计算的index出现重复,这个时候就需要用到链表结构了,其实我们的Node对象不仅仅是数组里面的一个元素,还是可能是一个链表的头节点,通过next指向链表的下一个Node对象节点.当出现重复index的时候则以下面的方式进行插入:

		mapDemo.put("name","Aiden")时,
		Node node3=new Node("galary","1K");
		int index=hash("galary")&length-1
		假如算出index=3,发现数组里面里面index=3的位置已经有Node对象node2了
		这个时候就转换成链表结构原来的Node对象成为链表的头节点,
		新put的Node对象,插入依次链表的尾部("尾插法"),如图:

另外当链表的长度达到一定值(默认为8)之后,会转换成红黑树的结构,如下图:

• get(key)的原理

      一般情况下,首先根据key值调用方法hash(key),通过与数组长度位与运算来计算出index值,然后直接返回tab[index].value即可.
  但是当计算出的index处的Node对象是链表结构或红黑树时,应该怎么办呢,因为那里所有Node的index都是相同的.

  • 当是链表结构时,这个时候会使用node.next来依次遍历比较链表上每个Node对象节点的key值是否和传入的key相等,直到匹配上为止.如下伪代码和图所示:

	mapDemo.get("galary");
	int index=hash("galary")&length-1,假如index=3,
	这个时候我们获取tab[3]发现tab[3].key为"nick",这显然不对.
	那么使用链表next指向下一个元素的特性进行遍历查找
	Node e=tab[3];
	while((e=e.next) != null){
		if("galary".equals(e.key)){//当遍历到e=Node7的时候显然要找的就是它
			return e.value;	
		}
	}

当是红黑树结构时则node实际就为TreeNode对象,由对象调用getTreeNode方法进行内部匹配,这里对红黑树的内部如何匹配就不做介绍了,感兴趣的朋友可以自行查资料.

注:

• 1. 为什么要进行位与运算来得出index呢,主要是为了实现index的均匀分布.均匀分布的原理如下:
           假如一个key="water",计算water的hashcode，结果二进制的11010111010110001010001 0111。假定HashMap长度是默认的16，计算Length-1的结果为十进制的15，二进制的1111。把以上两个结果做与运算，11010111010110001010001 0111 & 1111 = 0111，十进制是7，所以 index=7。另外为什么HashMap长度是默认16或者2的幂,因为当其长度为2的幂时,length-1的二进制位全为1,比如:31的二进制为11111;63的二进制为111111,所以，Hash算法最终得到的index结果，完全取决于Key的Hashcode值的最后几位。只要输入的HashCode本身分布均匀，Hash算法的结果就是均匀的,这就就是为什么是和length-1做位与运算,而不是其他值.
• 2.  Node键值对用来存放key-value的,Java8之前是是使用的Entry键值对,Node和Entry均实现Map.Entry接口.
• 3. 尾插法,在链表的尾部依次插入新的Node节点,Java8之前都是使用的头插法,即每一个新的Node都替代原来的头节点,原来的头节点变成了由新的Node节点用next指向.

• 源码解读

• put(key,value)方法源码解读

public V put(K key, V value) {     return putVal(hash(key), key, value, false, true); //此处参数内hash(key),实际上是获得key的hashCode值 } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {// onlyIfAbsent值为false的时候表示直接覆盖已存在的key的value值,为true时oldValue为null则才会覆盖     Node[] tab; // 声明一个tab数组     Node p; // 声明一个节点Node键值对     int n, i; // n表示tab的size; 表示即将把值put到某个Node(key-value)的index     if ((tab = table) == null || (n = tab.length) == 0)         n = (tab = resize()).length;                 // 如果tab为空或者长度为0时,就初始化tab(初始长度为16),并将长度值赋给n     if ((p = tab[i = (n - 1) & hash]) == null) // 当(n - 1) & hash 位与运算的结果为key对应的index,当为控的时候         tab[i] = newNode(hash, key, value, null); // 则调用newNode方法新建一个Node对象赋值给tab[i]     else { // 进入此else的代码块,则表示tab对应index必定已存在Node对象         Node e; K k; // 泛型 对象k 代表key     if (p.hash == hash&& ((k = p.key) == key || (key != null && key.equals(k))))// 当对应index上的Node的hash值与传入进来的key的hash值相等并且Node的key和传入的key也相等时则覆盖value值         e = p;     else if (p instanceof TreeNode) // 当上面不成立的时候,则说明此Node可能是红黑树或者链表. 当 是红黑树的时候         e = ((TreeNode) p).putTreeVal(this, tab, hash, key, value); // 当为红黑树时,调用putTreeVal方法,此方法内部会遍历红黑树,如果已存在则返回被覆盖的Node,否则返回null     else {  // 当为链表时         for (int binCount = 0;; ++binCount) { // 循环遍历链表     if ((e = p.next) == null) { // 当p.next为空时          p.next = newNode(hash, key, value, null);// 则newNode方法新建一个Node对象赋值给p.next         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st // 当链表达到一定长度(默认8)后,调用treeifyBin方法转换成红黑树的结构     treeifyBin(tab, hash); // 当遍历到p.next为空时 则表示找到了可以放置put进来的key-value的地方,所以要结束链表遍历     }     if (e.hash == hash&& ((k = e.key) == key || (key != null && key.equals(k)))) // 当p.next不为空时,并且hash值和传入的hash值相等,key值也相等时,则覆盖值,结束循环         break; // 则表示覆盖值,结束循环 p = e; //因为链表的遍历是 p.next.next.next...这种形式,所以最后需要将e赋给p  }      }      if (e != null) { // existing mapping for key //此处是真正执行覆盖操作的地方         V oldValue = e.value;         if (!onlyIfAbsent || oldValue == null) //onlyIfAbsent传入为false,所以会直接覆盖e原来的value值     e.value = value; afterNodeAccess(e); //afterNodeAccess此方法下面没有代码所以无实际意义 return oldValue; // 这个地方可以看出 当我们put重复的key-value时 会返回被覆盖的oldValue,虽然我们一般不关心put时候的返回值       }     }     ++modCount; //modCount是统计map被修改次数的      if (++size > threshold) //当tab的size大于阈值的时候则需要调用resize方法进行扩容          resize();afterNodeInsertion(evict); //afterNodeInsertion此方法下面没有代码所以无实际意义      return null; //当put的时候不存在覆盖值的时候则返回null }

• get(key)源码解读

public V get(Object key) {
		Node e;
		return (e = getNode(hash(key), key)) == null ? null : e.value;
	}

	final Node getNode(int hash, Object key) {
		Node[] tab;
		Node first, e;
		int n;
		K k;
		if ((tab = table) != null && (n = tab.length) > 0 // 当tab不为空并且长度不为0的情况下
				&& (first = tab[(n - 1) & hash]) != null) {// 并且通过hash值和长度-1的位运算计算出的table[index]不为空
			if (first.hash == hash &&                           // check匹配上的index处的节点,比较key值是否相等
					((k = first.key) == key || (key != null && key.equals(k))))
				return first;			                        //相等则直接返回节点
			if ((e = first.next) != null){                      //当第一个节点匹配不上则就说明是链表或者红黑树
				if (first instanceof TreeNode)                              //当节点元素为红黑树的时候
					return ((TreeNode) first).getTreeNode(hash, key);//红黑树TreeNode内部匹配结果
				do {
					if (e.hash == hash&& ((k = e.key) == key || (key != null && key.equals(k))))
					            	            //当为链表的时候则使用next指针遍历整个链表直到匹配上或者遍历完
						return e;
				} while ((e = e.next) != null);//当下一个节点不为空时,继续比较key值是否匹配(执行do{}代码块)
			}
		}
		return null;
	}