【HashMap】简单源码解析

1. 初始化创建HashMap对象

---

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // 默认加载因子为0.75
    }

public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity); //这里的threshold在tab[]槽位没有初始化之前代表的是initialCapacity容量，一般为2的幂次方
    }

进一步了解tableSizeFor，tableSizeFor方法是为了获取在大于等于cap的最小的2的幂次方值，将容量设置为2的幂次方是为了在获取槽位结点p = tab[i = (n - 1) & hash]时的与运算可以减少哈希碰撞，最大限度分散结点分布。

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;
    }

这里的cap-1的原因是为了避免初始化容量大于输入值，假设cap=16，没有减1操作，那么最后获取的cap的值得为32；返回n+1是为了避免返回结果为0的值，假设cap=1,n经过一系列或运算后的结果为0，返回容量大小为0不符合期望。正常情况下假设cap=14，经过运算后返回的结果值为16

2. put

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;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            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;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

2.1 刚创建对象，存放键值对

当hashMap实例对象的size小于阈值threshold，并且数组槽位上没有结点时，此时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;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null); //创建新节点并存放在对应数组槽位上
        
        ++modCount; //记录被修改的次数
      
        afterNodeInsertion(evict);
        return null;
    }

这里在resize方法里初始化tab[]，在resize的方法里实际执行为

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table; //null
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold; //为默认的16
        int newCap, newThr = 0;
        
        
        if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr; //16
       
        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];
        table = newTab;
        
     
        return newTab;
    }

2.2 当hashMap实例对象的size大于阈值时会进行扩容

if (++size > threshold)
            resize();

这里的resize方法实际执行为

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length; //16
        int oldThr = threshold;  //12
        int newCap, newThr = 0;
        if (oldCap > 0) {
            //newCap值为oldCap（16）的两倍，为32
           if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold，为24
        }
       
        threshold = newThr; //24
        @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 该数组结点为链表结点
                        Node<K,V> loHead = null, loTail = null; //这个链表记录的是当(e.hash & oldCap) == 0为真的情况下的结点链表，这个链表在新的数组上存放的位置依旧在原下标【j】槽位上
                        Node<K,V> hiHead = null, hiTail = null; //这个链表记录的是当(e.hash & oldCap) == 0为假的情况下的结点链表，这个链表在新的数组上的下标为 【j+oldCap】位置的槽位上
                        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;
    }

2.3 当新的key值、hash值和数组槽位上的结点的key、hash值相同时

当新的key值、hash值和数组槽位上的结点的key、hash值相同时，会直接替换掉旧的值

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
       p = tab[i = (n - 1) & hash]；
        
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
           
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

2.4 当新的key值、hash值和数组槽位上的结点的key、hash值不相同时【不分析树节点情况】

当新的key值、hash值和数组槽位上的结点的key、hash值不相同时，在槽位上的结点会形成一条链表，依次遍历链表，如果在链表上有节点的key和hash值和新增结点的一样，那么会替换链表上的结点；否则在链表尾结点新增一个结点

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        p = tab[i = (n - 1) & hash]；
        
            Node<K,V> e; K k;
                e = p.next；
                for (int binCount = 0; ; ++binCount) {
                   //遍历完所有链表结点，没有发现和新增的结点有相同的hash或者key的结点，则新增一个结点；这里的结点e为null，不会走下面的替换结点值的代码
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //当链表结点数据大于等于8的时候，会转换为红黑树【也不一定，如果实例对象的size小于64，那不会转化为红黑树，只会扩容数组】
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //链表上节点的key和hash值和新增结点的一样，那么会替换链表上的结点
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            //替换结点值
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

2.5 当链表结点数目大于8但是size小于64，那么不会从链表转换为红黑树，只会进行扩容；但是链表节点数目大于8并且实例对象的size大于等于64，那么会将链表转化为红黑树