HashMap源码解析理解与总结

本文章包含个人理解与参考文章部分内容，参考文章链接如下，侵权请联系我删除，谢谢
参考文章
其次，由于自始至终搞不定csdn这玩意的排版，所以排版很有问题，分享有道云笔记的内容
链接地址

欢迎留言进行讨论

HashMap在JDK1.8结构上为数组+链表+红黑树；JDK1.8之前都为数组+链表结构；

链表的查询操作都是O(N)的时间复杂度；
红黑树结构中，增删改查都是O(log n)

因此，HashMap中数组table中某Node形成的链表长度超过TREEIFY_THRESHOLD（8） 时，会将其转换为红黑树，同理当红黑树小于UNTREEIFY_THRESHOLD（6）时，红黑树会转换为链表。
扩容：HashMap底层数组默认初始容量为16，负载因子为0.75，也就是说当数量达到16*0.75=12时就会将当前16的容量进行扩容。扩容需要进行reHash、复制数据等操作（及其消耗性能）。

参数

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    //序列号，序列化的时候使用。
    private static final long serialVersionUID = 362498820763181265L;
    /**默认容量，1向左移位4个，00000001变成00010000，也就是2的4次方为16，使用移位是因为移位是计算机基础运算，效率比加减乘除快。**/
    // 2的n次幂 
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    //最大容量，2的30次方。
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //负载因子，用于扩容使用。
    //负载因子过大时，填入新的元素时,冲突的机会将很大,查找的成本高
    //负载因子过小时，空间浪费
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //当某个桶节点数量大于8时，会转换为红黑树。
    static final int TREEIFY_THRESHOLD = 8;
    //当某个桶节点数量小于6时，会转换为链表，前提是它当前是红黑树结构。
    static final int UNTREEIFY_THRESHOLD = 6;
    //当整个hashMap中元素数量大于64时，也会进行转为红黑树结构。
    static final int MIN_TREEIFY_CAPACITY = 64;
    
    -----------------------上方为常量--------------------------
    -----------------------下方为变量--------------------------
    
    //transient关键字表示该属性不能被序列化
    节点表(数组的每一个位置上存储一个节点表)
    transient Node<K,V>[] table;
    //将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
    transient Set<Map.Entry<K,V>> entrySet;
    //元素数量
    transient int size;
    //统计该map修改的次数
    transient int modCount;
    //临界值，也就是元素数量达到临界值时，会进行扩容。(=capacity*loadFactor)
    int threshold;
    //也是负载因子，
    final float loadFactor;  

HashMap初始化数组大小为DEFAULT_INITIAL_CAPACITY （2的n次幂 16）16时统计结果的最优解，TREEIFY_THRESHOLD ，UNTREEIFY_THRESHOLD 也是如此

结点内部类

static class Node<K,V> implements Map.Entry<K,V> {
    // 当前key的hashcode
    final int hash;
    final K key;
    V value;
    // next指向下一个节点
    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;
    }
 }

结点内部类，是一个单向链表，组成 数组Node<K,V>[] table

存储的规则一般是 hash(key)%len获得，就是元素的key的哈希值对数组的长度取模得到。 存储键值对时，实际上是存储在一个Entry对象中，通过key计算出Entry对象的存储位置。Key -->Value的对应关系，通过key-->Entry--->value实现

红黑树结构

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    
        boolean red;
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }
}

构造函数

（1）hash（key）
（2）初始化数组大小
（3）根据hash&（n-1）得到位置，进行存储
（4）存储方式：

• 值的覆盖；
• 链表
• 红黑树
  （5）数组大小超过阈值进行扩容

/**
 * 用指定的初始值构造一个空的<tt>HashMap</tt>
 * capacity（容量） and load factor（负载因子）.
 *@throws 当初始容量（initialCapacity）为负数或者负载因子（loadFactor）是非正的，报出IllegalArgumentException 
 */
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;
    调用tableSizeFor方法,因为HashMap的容量必须为2的幂次方，例：15----2^4
    this.threshold = tableSizeFor(initialCapacity);
}
/**
 * 用指定的初始值构造一个空的HashMap
 *默认负载因子为(0.75) 需指定初始容量 
 */
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
 * 默认初始容量为16，负载因子为0.75
 * (16) and the default load factor (0.75).
 */
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//创建一个内容为参数m的内容的哈希表
//采用默认的加载因子
public HashMap(Map<? extends K, ? extends V> m) {
       this.loadFactor = DEFAULT_LOAD_FACTOR;
       this.putMapEntries(m, false);
}

    -----------------------上方为四种构造函数--------------------------
    -----------------------下方为构造函数使用的方法--------------------------

// 返回大于输入参数且最近的2的整数次幂的数
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;
}
// 将整个集合中的数据放到HashMap中保存
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    int s = m.size();
    if (s > 0) {
        //数组还是空，初始化参数
        if (table == null) { 
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                     (int)ft : MAXIMUM_CAPACITY);
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        //数组不为空，超过阈值就扩容
        else if (s > threshold)
            resize();
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
            //先经过 hash() 计算位置，然后复制指定 map 的内容
            putVal(hash(key), key, value, false, evict);
        }
    }
}

添加元素

put方法

hash函数的实现：

1. 高十六位不变，低十六位与高十六位进行异或，
2. hash&（n-1）---->得到下标
   
   Put过程：
   
3. 对Key求hash值，然后计算下标。
4. 如果没有碰撞，直接放入桶中。
5. 如果碰撞了，以链表的方式连接到后面。
6. 如果链表长度超过阀值（TREEIFY_THRESHOLD(=8)），则链表转换为红黑树。
7. 如果节点已经存在，则替换旧址，并return旧值。
8. 如果桶满了（容量*负载因子），则需要进行resize（扩容）。

//添加指定的键值对到 Map 中，如果已经存在，就替换,并且返回oldvalue
public V put(K key, V value) {
    //调用 hash() 计算位置
    //调用putVal()方法进行保存key-value
    return putVal(hash(key), key, value, false, true);
}
// hash 将hashCode带符号右移16为 前面补0
//在于原值进行异或运算
//相当于将二进制的hashcode为32为 分为高十六位和低十六位
//高十六位与低十六位进行异或运算，以此降低碰撞概率
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

putVal()

存值： p = tab[i = (n - 1) & hash]
这时，n等于默认值16，n-1=15，二进制为01111
拿hash与n进行异或运算得到存储位置（为了得到一个十六以内的数）
如果n=15，n-1=14； 那么二进制为01110，这时无论原本hash的最后一位为0还是1 与n异或后都是0 这将大大的提高了碰撞的概率，这也是为什么容量一定要为2的n次幂的原因
至于为什么都采用异或运算 请看文章尾部注解

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时, 调用resize初始化数组table, 并令tab指向数组table，n=默认大小16
        if ((p = tab[i = (n - 1) & hash]) == null)  //如果新存放的hash值没有冲突
            tab[i] = newNode(hash, key, value, null);  
            //则只需要生成新的Node节点并存放到table数组中即可
        else {  //否则就是产生了hash冲突，三个解决方式（1）value覆盖（2）链式存储（3）红黑树方式存储
            Node<K,V> e; K k;
            if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k)))) 
                e = p;  //如果hash值相等且key值相等, 则令e指向冲突的头节点
            else if (p instanceof TreeNode)  
            //如果头节点的key值与新插入的key值不等, 并且头结点是TreeNode类型,说明该hash值冲突是采用红黑树进行处理.
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);  
                //向红黑树中插入新的Node节点
            else {  //否则就是采用链表处理hash值冲突
            // JDK1.7是头插法，整个链表向下移动，多线程进行操作时，容易死循环
            // JDK1.8是尾插法
                for (int binCount = 0; ; ++binCount) {  
                //遍历冲突链表, binCount记录hash值冲突链表中节点个数
                    if ((e = p.next) == null) {  //当遍历到冲突链表的尾部时
                        p.next = newNode(hash, key, value, null);  //生成新节点添加到链表末尾
                        if (binCount >= TREEIFY_THRESHOLD - 1)
                         //如果binCount即冲突节点的个数大于等于 (TREEIFY_THRESHOLD(=8) - 1),
                         //便将冲突链表改为红黑树结构, 对冲突进行管理, 否则不需要改为红黑树结构
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))  //如果在冲突链表中找到相同key值的节点, 则直接用新的value覆盖原来的value值即可
                        break;
                    p = e;
                }
            }
            if (e != null) { // 说明原来已经存在相同key的键值对
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)  
                //onlyIfAbsent为true表示仅当<key,value>不存在时进行插入, 为false表示强制覆盖;
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;  //修改次数自增
        if (++size > threshold) //当键值对数量size达到临界值threhold后, 需要进行扩容操作.
            resize();
        afterNodeInsertion(evict);
        return null;
    }

扩容：resize()
threshold=DEFAULT_INITIAL_CAPACITY （默认容量）DEFAULT_LOAD_FACTOR（负载因子） =160.75=12
容量： newCap = oldCap << 1 右移1 即乘以2
阈值： newThr = oldThr << 1
新建数组后需要重新将原本的键值对进行迁移；
if ((e.hash & oldCap) == 0) 16的二进制为10000
e.hash 到数第五位为0，那么最终结构为0---->链表还是原来的位置村粗
e.hash 倒数第五位为1，那么最终结果为1---->链表就是原本的的位置加+oldCap（16）----> 例如原本是1 现在是1+16=17
因此得出结论：

扩容操作，将容量扩充为原本的两倍，然后对每一个节点重新计算hash值，这个值只可能在两个位置，一个是原下标的位置，另一种是在下标为<原下标+原容量>的位置

final Node<K,V>[] resize() {
    //保存当前的节点集合数据
    Node<K,V>[] oldTab = table;
    //保存旧的元素个数
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //保存旧的扩容阈值
    int oldThr = threshold;
    //设置新的容量、扩容阈值
    int newCap, newThr = 0;
    if (oldCap > 0) {
        //旧的容量大于最大容量
        if (oldCap >= MAXIMUM_CAPACITY) {
            //扩容阀值设为Integer的最大值
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //新的容量为旧的容量的两倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            //如果旧容量小于等于16，新的阈值就是旧阈值的两倍
            newThr = oldThr << 1; 
    }
    //如果旧容量为 0 ，并且旧阈值>0，说明之前创建了哈希表但没有添加元素，初始化容量=阈值
    else if (oldThr > 0) 
        newCap = oldThr;
    else {               
        //旧容量、旧阈值都是0，说明还没创建哈希表，容量为默认容量，阈值=容量*加载因子
        newCap = DEFAULT_INITIAL_CAPACITY;  
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //如果新的阈值为 0 ，就得用 新容量*加载因子 重新计算一遍
    if (newThr == 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
    table = newTab;
    //将暂存旧数据的OldTab变量的数据遍历复制回table变量
    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)
                    //e.hash & (newCap - 1)=e.hash % newCap，重新索引
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    //如果旧哈希表中这个位置的桶是树形结构，就要把新哈希表里当前桶也变成树形结构
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else {
                    //保留旧哈希表桶中链表的顺序
                    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;
}

============================================
get和remove没啥亮眼操作就意思意思了

get()

public V get(Object key) {
        Node<K,V> e;
        //调用getNode，通过hash值和key来获得对应的值，如果没有，返回null
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
  final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; 
        Node<K,V> first, e; 
        int n; 
        K k;
        //e.hash & (newCap - 1)=e.hash % newCap ，得到目标的位置
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {  //first指向hash值对应数组位置中的Node节点
            if (first.hash == hash && 
            // 如果first节点对应的hash和key的hash相等(在数组相同位置,只是说明 hash&(n-1) 操作结果相等, 
            //说明hash值的部分低位相等, 并不代表整个hash值相等), 并且first对应的key也相等的话, first节点就是要查找的
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {  //存在hash冲突
                if (first instanceof TreeNode)  //由红黑树对hash值冲突进行管理
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);  //查找红黑树
                do {  //hash值冲突是由链表进行管理
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);  //对链表进行遍历
            }
        }
        return null;
    }

remove()

public V remove(Object key) {
        //临时变量
        Node<K,V> e;
        /**调用removeNode(hash(key), key, null, false, true)进行删除，
        //第三个value为null，表示，把key的节点直接都删除了，不需要用到值，如果设为值，
        //则还需要去进行查找操作**/
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }
    
    /**第一参数为哈希值，第二个为key，第三个value，第四个为是为true的话，则表示删除它key对应的value，不删除key,第四个如果为false，则表示删除后，不移动节点**/
    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        //tab 哈希数组，p 数组下标的节点，n 长度，index 当前数组下标
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        //哈希数组不为null，且长度大于0，然后获得到要删除key的节点所在是数组下标位置
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            //nodee 存储要删除的节点，e 临时变量，k 当前节点的key，v 当前节点的value
            Node<K,V> node = null, e; K k; V v;
            //如果数组下标的节点正好是要删除的节点，把值赋给临时变量node
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            //也就是要删除的节点，在链表或者红黑树上，先判断是否为红黑树的节点
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    //遍历红黑树，找到该节点并返回
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else { //表示为链表节点，一样的遍历找到该节点
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        /**注意，如果进入了链表中的遍历，那么此处的p不再是数组下标的节点，而是要删除结点的上一个结点**/
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            //找到要删除的节点后，判断!matchValue，我们正常的remove删除，!matchValue都为true
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                //如果删除的节点是红黑树结构，则去红黑树中删除
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                //如果是链表结构，且删除的节点为数组下标节点，也就是头结点，直接让下一个作为头
                else if (node == p)
                    tab[index] = node.next;
                else /**为链表结构，删除的节点在链表中，把要删除的下一个结点设为上一个结点的下一个节点**/
                    p.next = node.next;
                //修改计数器
                ++modCount;
                //长度减一
                --size;
                /**此方法在hashMap中是为了让子类去实现，主要是对删除结点后的链表关系进行处理**/
                afterNodeRemoval(node);
                //返回删除的节点
                return node;
            }
        }
        //返回null则表示没有该节点，删除失败
        return null;
    }

注解：想必看到这张图就明白为什么了吧？