HashMap源码学习

自己在学习的时候总感觉看懂了又没有看懂，总有一层雾，所以干脆写个博文，看能不能彻底弄懂。
测试用代码：
        
HashMap<String,String> map = new HashMap<>();
map.put("1","2");
map.put("2","4");
map.put("3","6");
map.put("4","8");
map.put("5","1");
map.put("6","1");
map.put("7","1");
map.put("8","1");
map.put("9","1");
map.put("10","1");
map.put("11","1");
map.put("12","3");
map.put("13","3");

put方法：

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

//hash(key)方法
static final int hash(Object key) {
    int h;
    //此处的key.hashCode()就是一个获取hashCode的码值，例如传入key的类型是Integer/String，就调用Integer/String对应的hashCode方法
    //h>>>16,即移位
    // 1111 1111 0000 0000  移位以后结果为 0000 0000 1111 1111
    // ^ 为异或运算符（相同为0，不同为1） 
    // 1111 ->15
    // 0011 ->3
    // 1100 ->12(结果)  这个与15^3的结果是一致的。
    // 所以下面这句代码的含义为 获取key的hashCode码以后，与右移16位以后的值进行异或处理，被右移以后的前面的值肯定是补0的
    // 0101 0100 1010 1111 1111 0000 1111 0000->h.hashCode
    // 0000 0000 0000 0000 0101 0100 1010 1111 ->h>>>16
    // 此处的 (h = key.hashCode()) ^ (h >>> 16) 就是运算后的结果。
    // 异或和右移的计算效率要比直接加减乘除是高的，相当于低于2的15次方的hashCode保留原值，大于2的15次方的才需要实际上的异或处理。为什么这么设计，我就不太清楚了，有大神明白的，可以告知一下。
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

putVal方法：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //此处的table为当前putVal之前的值，即map.put("2","4")此，table 中为("1","2")，map.put("3","6")时，table中为("1","2")和("2","4")。
        //new HashMap()的时候并不会进行扩容的
        //通过以上描述，以下扩容是在我们new以后，第一个put的时候才会进入的操作。
        if ((tab = table) == null || (n = tab.length) == 0)
        	// 扩容处理
        	// newCap = DEFAULT_INITIAL_CAPACITY;
            // newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
            //  返回结果
            // Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
            // 默认初始化容器长度为2的4次方->16
            //static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
        	//具体的扩容代码在下面贴出
        	
            n = (tab = resize()).length;//根据上面注释可知，返回结果为16
            
            //根据上面所说的，此处hash值就是原值 ,字符串1(String)->49(Integer),这段代码就是String类的hashCode方法，一看就明白
            // &运算符：如果相对应位都是1，则结果为1，否则为0
            // p = tab[i = (n - 1) & hash] -> p = tab[i = (16 - 1) & 49] -> p = tab[1] 
            // 这个就是放值时key的hashCode值是否有值，未被占直接使用，被占的话就需要转成链表了
        if ((p = tab[i = (n - 1) & hash]) == null)
        	//创建节点并赋值
            tab[i] = newNode(hash, key, value, null);
        else {
        	//这个代码块就是key的hashCode被占用的处理，被占用也是区分几种处理方式的。
        	
            Node<K,V> e; K k;
            // 这句比较简单，此处的p是HashMap中被冲突的值，当hashCode相同时，再比较一下键是否相等，相等直接替换就可以了，不相等再进行处理。
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
			// 当链表超过8位时，会被转成红黑树，如果冲突的hashCode是红黑树中的，就需要在红黑树中进行替换。具体的逻辑还没有学习。
            else if (p instanceof TreeNode)
            	此处暂未学习。
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
            	//当链表未到8位时，next指针是前指后，例 1.next->2.next->3.next->null。
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                    	//next的指向，谁后加，谁被指
                        p.next = newNode(hash, key, value, null);
                        // 当长度为8时，转换成红黑树
                        //static final int TREEIFY_THRESHOLD = 8;
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        	//链表转红黑树，转换完成后退出循环。 此处暂未学习。
                            treeifyBin(tab, hash);
                        break;
                    }
                    //链表中hashCode都是相同的，如查找到其中key值相等则退出循环
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    //整个链表遍历完成后，不论是否转成红黑树，e==null，如果链表未遍历完成即发现有相等值，则退出遍历，下面进行替换
                    p = e;
                }
            }

			//如果被替换节点e不为空，则进行值替换，并返回被替换下来的值
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //每对HashMap进行一次操作就会进行一次自增。用来记录该HashMap被操作的次数
        ++modCount;
        //size就是我们实际使用中的大小，当新添加数据后超过了最大容量后，就需要进行一次扩容
        if (++size > threshold)
        	//扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }

resize()扩容方法：

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    // 旧数据长度（这个为建HashMap的长度，例 new HashMap(4）,这里的length==4
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 旧哈希桶长度
    int oldThr = threshold;//哈希桶长度
    int newCap, newThr = 0;
    if (oldCap > 0) {
    	// 当新建的HashMap超过2的30次方时，哈希桶长度为2的31次方
    	// static final int MAXIMUM_CAPACITY = 1 << 30;
        if (oldCap >= MAXIMUM_CAPACITY) {
        	// public static final int   MAX_VALUE = 0x7fffffff;//2的31次方
            threshold = Integer.MAX_VALUE;
            //表示这已经是极限了，你不用再扩了
            return oldTab;
        }
        //这个是我们正常扩容所用的， 16<你翻倍后的容量<2的30次方 ，当你在这个区间时，将你的哈希桶翻倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
                 //普通翻倍操作
            newThr = oldThr << 1; // double threshold
    }
    //当new HashMap(4)的时候，是不符合上面的扩容范围区间的，但是也需要扩容啊，于是，就进到下面了
    // 此处也是第一次put的时候进入，因为非第一次的时候oldCap是不可能为0的，不会进入此处。
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
    	//默认新建HashMap，第一次put的时候进入
    	//static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;  table初始化为16
        newCap = DEFAULT_INITIAL_CAPACITY;  
        //static final float DEFAULT_LOAD_FACTOR = 0.75f;
        //这个就是经常说的哈希桶长度，即table.length*0.75f;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //与上面new HashMap(4)的时候是一致的，当oldCap>0但是范围又不在 16<翻倍后的容量<2的30次方 区间的时候，就来这里了
    if (newThr == 0) {
    	//当前table.length*0.75f,重新计算哈希桶的值大小
        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;
            //将oldTab的值给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
                	//链表搬运，具体逻辑没梳理
                    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)
                                hiHead = 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;
}

还有好多需要学习的，红黑树需要学习一下，还有好些地方的代码逻辑并不清楚，只是有一个大概的印象。
等学完红黑树再把这个代码补充一下。
写博客还是很有助于理解的。

新人学习源码，总有一种雾里看花的感觉，不够透彻，如有地方写的不对，请各位大神指出。