HashMap源码解析《一》put方法

在jdk1.8里边 hashmap的实现原理不仅仅只由位桶+链表实现 ，增加位桶+红黑树实现，在桶中链表存储的元素个数到达阈值时(默认为8)，将在底层将链表转为红黑树,但因为我本人红黑树掌握的并不好，所以不讨论有关红黑树，本文主要讲解基础，hashmap的put方法，其他请等待下文；

一，所涉及到的名词；

1，bucket   桶，对于系统开始初始化hashmap的时候，会创建一个长度为capacity的数组，数组里边存储元素的位置被称为桶，存储一个Node<K,V>

2，capacity    容量  capacity就是指HashMap中桶的数量，默认初始值为16，必须为2的幂

3，size  表示HashMap中存在KV的数量(数组和链表的总和)，如果size到达threshold极限值会进行扩充。

4,LoadFactor 负载因子(装载因子) ，装载因子用来平衡HashMap满的程度，默认值为0.75f.计算HashMap的实时装载因子的方法为：size/capacity,而不是用已占用桶的数量去初以capacity  满的程度就是当前的桶中被占用了多少。  例如 现在capacity=16，占用了一个桶size = 1， 1/16 = 0.0625     就是表示现在有多满。

5，threshold   极限值    size的值到达极限值之后就会进行扩充。

threshold=capacity*loadFactor         例如现在capacity=16, loadFactor = 0.75   16*0.75 = 12  意思就是当现在桶和链表中的bin总量等于12 时，就会扩充

二，源码分析：

1.初始化：

HashMap 继承于AbstractMap，实现了Map,Cloneable,Serializable接口

Hashmap是无序的，有序的有TreeMap,LinkedHashMap等

 

静态成员定义：

static final int DEFAULT_INITIAL_CAPACITY = 1<<4;    //初始值为16，并且必须是2的幂

static final int MAXIMUM_CAPACITY = 1<<30;            //最大容量 2^30

static final float DEFALT_LOAD_FACTOR = 0.75f;       //负载因子

static final int TREEIFY_THRESHOLD = 8;             //由链表转为数的极限值

static final int UNTREEIFY_THRESHOLD = 6;          //由树转为链表的阈值

static final int MIN_TREEIFY_CAPACITY = 64;         

//当桶中的数据被树化时最小的hash表容量（如果没有达到这个阈值，即hash表容量小于MIN_TREEIFY_CAPACITY，当桶中bin的数量太多时会执行resize扩容操作）这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。

 

桶中的每个数据是Node<k,v>的实例，其中包含Node(int hash,K key,V value, Node<K,V> next);  也就是说桶中的元素所包含这些属性

Node 是 hashMap中的一个内部静态类，他的初始定义如下：

他的内部重写了equals和hashcode方法

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

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

我们一般使用hashmap  实例化使用无参的构造方法， 只是初始化和负载因子

还有其他三种种构造方法，分别为其指定桶的大小，桶的大小和负载因子，将一个新的map填充进去

构造方法在下一章讲解  一并讲解tableSizeFor方法

2.put方法  （重点）

HashMap中我们用的最多的就是put,get方法了。

在这之前我们先了解一下put方法所相关的两个方法

hashmap在初始化的时候不会去初始化Node<k,v> []  table   只有在你往map中添加值的时候他才回去判断table有没有被初始化，没有则去初始化，并设置默认大小；

初始化： 红色 注释是初始化过程要执行的

（1）.有关桶的初始化和size的扩充（）

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;    //让oldTab和table引用同一内存空间
        int oldCap = (oldTab == null) ? 0 : oldTab.length;  //判断当前桶数组是否被初始化过  若没有 则让old（容量）等于0
        int oldThr = threshold;      
        int newCap, newThr = 0;
        if (oldCap > 0) {
                 //这次操作是在扩充数组
                 //当容量扩充到大容量时，将阈值也设置为最大 ，也就是说当size到达阈值的时候在进行扩充，但是下次真的到达可能就不能扩充了
             if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;  //阈值设置为int能达到的最大值
                return oldTab;
              }
               //先让新的容量等于旧容量二倍 之后新容量没到达最大值， 并且之前容量大于等于初始化大小则将阈值扩大二倍
    	     else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold 
		} 
	 else if (oldThr > 0) // initial capacity was placed in threshold
		//如果旧的阈值大于0， 则赋值给新的容量 在这里操作的前提是在初始化hashmap时调用的是带参的构造方法，
              //设置过阈值，但是阈值实际是容量值 详情请看在带参初始化时调用tableSizeFor方法
		newCap = oldThr;
	 else { 
		//桶数组没有被初始化过，且初始化hashmap时调用的是无参构造 // zero initial threshold signifies using defaults
              //容量大小为默认
     		 newCap = DEFAULT_INITIAL_CAPACITY;
               // 计算新的阈值
            	 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); 
		} 
	if (newThr == 0) {
           //这里主要是在oldThr>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];
           //并且将新的空间赋值给原始桶数组
 	table = newTab; 
	if (oldTab != null) {
	//因为扩充之后 需要给新的数组进行赋值
             for (int j = 0; j < oldCap; ++j){
		 Node<K,V> e;
		 if ((e = oldTab[j]) != null) { 
			oldTab[j] = null; 
			if (e.next == null) 
			   newTab[e.hash & (newCap - 1)] = e;
		        else if (e instanceof TreeNode) 
			 ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); 
			else { // preserve order
				//在这里遍历链表 并且将值存放入 新的table中
				//这里的代码分析主要在另一篇文章中讲解
                     		  Node<K,V> loHead = null, loTail = null; 
				  Node<K,V> hiHead = null, hiTail = null; 
				  Node<K,V> next;
			   do { next = e.next; 
				if ((e.hash & oldCap) == 0) { 
					if (loTail == null) 
						loHead = e; 
					else 
						loTail.next = e; 
					loTail = e; 
				} else { 
					if (hiTail == null) 	
						iHead = e; 
					else 
						hiTail.next = e; 
					hiTail = e; 
				}
			   } while ((e = next) != null);
			 if (loTail != null) {
				 loTail.next = null; 
			         newTab[j] = loHead;
			   } 
		         if (hiTail != null) { 
				hiTail.next = null; 
				newTab[j + oldCap] = hiHead; 
			}
    		 } 
		}
	     } 
	}
   //返回新数组
 return newTab;
 }

（2）.hashmap中hash值获取方式

 static final int hash(Object key) {
        int h;
      //如果他的主键为null则hash值0，也就是hashmap允许键为null，但只是存在一个
      //如果主键空，获取他的主键不为空，则获取他的hashcode值，并将hashcode值无符号右移16位之后按位相异或
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

// 我们在put的时候，传入的是String类型的键值，存放的就是String类型吗？

我们一步一步深入解析

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

这是put()方法的源码，主要操作在putVal中，

Put方法的执行过程大致是这样的，取得键值，并取得到键的hash值，根据hash&(数组长度-1)作为索引寻找桶的位置，然后检测该索引下是否存在值，没有，将Node(前边有相应的构造方法)类型的值加入参数已注入，若有，先判断他们的hash值是否一致(不同的hash值&相同值可能存在 结果一致，即索引一致)并且键值是否一致，若都一致，则覆盖对应的位置Node里边的值，并将原来的值返回，若不相等，遍历链表，若一直没有满足要求的值，则将当前Node存储在当前位置的桶中，并且将指针指向原来链表的首部。

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {

        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //判断桶数组是否进行过初始化，检验桶数组的容量
	 if ((tab = table) == null || (n = tab.length) == 0)
            //为空或未初始化则初始化表并设置容量
            n = (tab = resize()).length;
         //如果当前桶数组中没有和put进来的键发生hash碰撞，
        if ((p = tab[i = (n - 1) & hash]) == null)
 		//将该Node 放入对应的桶中    
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
     //桶中已存在对应hash值,键值也相同
          if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
         //红黑树，暂时不讨论
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
		//当前桶被占用，并且桶中元素和当前元素键不同，需要去遍历链表中的值。
                for (int binCount = 0; ; ++binCount) {
		   //遍历玩数组之后 都没找到
                    if ((e = p.next) == null) {
                         p.next = newNode(hash, key, value, null);
			//如果当前链表的长度到达了链表转为树的阈值
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
               //如果找到键值一样的，停止链表遍历
                   if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                 //没找完且没找到，则继续找，然当前引用指向下一个引用(c 语言链表的遍历)
                   p = e;
                }
            }
    //如果桶数组或者链表中存在和当前的Node键相等的
            if (e != null) { // existing mapping for key
                V oldValue = e.value;

        //如果允许覆盖值，或者之前的值为空      
  if (!onlyIfAbsent || oldValue == null)
                //覆盖
            e.value = value;
             //供LinkedHahMap继承使用的
            afterNodeAccess(e);
            //返回旧值
            return oldValue;
            }
        }
    
    // modCount字面意思就是修改次数
         ++modCount;

//即不存在碰撞 将Node放入桶表中 
//如果当前桶数组的size达到阈值，扩展
  if (++size > threshold)
     resize();

//供LinkedHahMap继承使用的 
afterNodeInsertion(evict); 
return null;
 }