Hashmap源码分析（jdk1.8）

1.初始化构造函数

HashMap<Integer,String> hashMap = new HashMap<>();
HashMap<Integer,String> hashMap = new HashMap<>(10);

构造函数：

//将负载因子设为0.75，然后初始化默认最大容量是16，负载因子是0.75，
//故默认容量是12，然后超过12就会扩容
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
//这是一个自己设置数组长度的构造函数
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

进入this中：

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)//如果设置的值小于0则抛出异常
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
        //这个MAXIMUM_CAPACITY是最大的容量为2的30次方，如果设置的值比这个最大的还要大，那么将设置的值改为2的30次方
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
        //如果负责因子为负数或者不是一个数字那么抛出异常
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

进入tableSizeFor：

static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        //>>>是无符号右移，具体的操作大家可以自己百度
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
        //返回的操作用了2个3元运算符，结果就是如果n不比最大的还要大，那么返回n+1
        //经过上面操作就是将n变为比n大的最小的2的次幂，比如设置的是10，那么就会变为16。
    }

最后就是将计算的容量返回给threshold ，这个threshold 就是边界值。
jdk8初始化长度不是在构造函数中，而是在put方法中。

put方法源码分析

进入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;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        //这个return就是计算出hash值，并且key可以为null，hash值是通过无符号右移和异或得出
    }

进入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;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
            //如果table为null，那么就对table进行扩容进入resize()方法
        if ((p = tab[i = (n - 1) & hash]) == null)
        //这里(n - 1) & hash就是计算出索引的值，并且结合key.hashCode()) ^ (h >>> 16就是hash%n，
        //为什么这样做呢，因为直接%效率就比较低，底层的位运算效率是最高的。
        //下面有张图片是计算索引值的过程可以参考一下
            tab[i] = newNode(hash, key, value, null);
        else {  //进入这里面的情况就是当存入的索引的重复时就进入这个
        		//比如key为1，value为6，然后就存入1和8这种情况
            Node<K,V> e; K k;
            if (p.hash == hash &&
            //这里是原来的table中的hash值和插入的hash值相比较
                ((k = p.key) == key || (key != null && key.equals(k))))
                //这里一个与运算，原来的key和插入的key相比较值，解释和上面一样
                e = p;//如果key和hash值相等，那么将原来的值复制给e，进入后面那个覆盖的if判断
            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) {//如果原来的table下个节点为空，则放入数据
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st           
                        //这里是判断是否大于8，如果不大于8就不执行
                            treeifyBin(tab, hash);
                            //如果大于8就进入treeifyBin中，下面有分析
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        //这里就是table中的next不为空的时候，比较table中第一个的hash值和插入的hash值，如果不相等break直接存入
                        break;
                    p = e;
                }
            }
            //这个if就是如果存入原来的key，那么将原来的value覆盖掉
            if (e != null) { // existing mapping for key
            //如果原来的值不为空
                V oldValue = e.value;//将原来的值给oldValue
                if (!onlyIfAbsent || oldValue == null)
                //onlyIfAbsent 是传进来的值为false，取反就为true
                    e.value = value;//将新的value把原来的值覆盖
                afterNodeAccess(e);
                return oldValue;//返回旧的值，put添加相同的key，返回的就是旧的值。
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

计算索引值的过程：

进入扩容的方法：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //oldCap是旧的数组长度为0
        int oldThr = threshold;//oldThr为旧的边界值也为0
        int newCap, newThr = 0;
        if (oldCap > 0) {  //旧的长度大于0
            if (oldCap >= MAXIMUM_CAPACITY) {//如果旧的长度大于最大的容量那么新的边界值为最大的值
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                     //旧的长度小于最大的最大的容量那么新的长度为旧长度的2倍
                     //并且旧的长度大于等于初始化的长度
                newThr = oldThr << 1; // double threshold
                //新的边界值为旧的边界值的2倍
        }
        //这里跳过因为oldCap 为0
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
        //上面都跳过，这个就是初始化扩容
            newCap = DEFAULT_INITIAL_CAPACITY;//默认长度为16
            newThr = (int)(DEFAULT_LOAD_FACTOR * //，默认长度为12 DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;//赋值给成员变量为12
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//创建一个新的数组为16
        table = newTab;//新的数组大小为16，初始化扩容就完毕返回上面的第一个if中，分析第二个if
        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
                        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;
    }

进入treeifyBin方法中：

final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        //判断数组的长度是否大于64，如果没有大于64就进行扩容
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
        //这种情况就是当链表长度大于8并且数组大于64才转换为红黑树
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                //把插入的值放入红黑树的根节点
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
                //这个do里面做的就是将值顺序插入hd是第一个节点，然后tl是最后一个节点，这里还没有变为红黑树
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
                //这个treeify就是真正的变为红黑树，这里就不分析源码了，主要是能力有限hh
        }
    }

上面就是关于Hashmap的put方法源码解析，内容比较多，建议大家可以分几个点细化一下看。
感谢观看！有什么问题或者交流的可以加我的qq997355706