关于JDK1.8的HashMap-白红宇

public class HashMap
    
      extends AbstractMap
     
          implements Map
      
       , Cloneable, Serializable复制代码

首先，继承关系与1.7无异（1.7楼主已经写过，可自行去查看）。

/** * The default initial capacity - MUST be a power of two. */static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16/** * The maximum capacity, used if a higher value is implicitly specified * by either of the constructors with arguments. * MUST be a power of two <= 1<<30. */static final int MAXIMUM_CAPACITY = 1 << 30;/** * The load factor used when none specified in constructor. */static final float DEFAULT_LOAD_FACTOR = 0.75f;/** * The bin count threshold for using a tree rather than list for a * bin.  Bins are converted to trees when adding an element to a * bin with at least this many nodes. The value must be greater * than 2 and should be at least 8 to mesh with assumptions in * tree removal about conversion back to plain bins upon * shrinkage. */static final int TREEIFY_THRESHOLD = 8;/** * The bin count threshold for untreeifying a (split) bin during a * resize operation. Should be less than TREEIFY_THRESHOLD, and at * most 6 to mesh with shrinkage detection under removal. */static final int UNTREEIFY_THRESHOLD = 6;/** * The smallest table capacity for which bins may be treeified. * (Otherwise the table is resized if too many nodes in a bin.) * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts * between resizing and treeification thresholds. */static final int MIN_TREEIFY_CAPACITY = 64;复制代码

DEFAULT_INITIAL_CAPACITY ：默认初始化大小复制代码

static final int MAXIMUM_CAPACITY = 1 << 30;最大容量复制代码

static final float DEFAULT_LOAD_FACTOR = 0.75f;默认加载因子复制代码

static final int TREEIFY_THRESHOLD = 8;static final int UNTREEIFY_THRESHOLD = 6;这两次参数用于使用链表还是树，与一个哈希桶中的元素数目有关。两个参数中展示了Java 8的HashMap在使用树和使用链表之间切换的阈值。当冲突的元素数增加到8时，链表变为树；当减少至6时，树切换为链表。中间有2个缓冲值的可能原因是避免频繁的切换浪费计算复制代码

static final int MIN_TREEIFY_CAPACITY = 64;关于树的最小容量，原本注释解释如下可以对容器进行树化的最小表容量，在大小和树形阈值之间应该至少设置4 * TREEIFY_THRESHOLD以避免冲突复制代码

static class Node
    
      implements Map.Entry
     
       {    final int hash;    final K key;    V value;    Node
      
        next;    Node(int hash, K key, V value, Node
       
         next) {        this.hash = hash;        this.key = key;        this.value = value;        this.next = next;    }从1.7的Entry变成了Node，其他参数基本一致，Node主要用于hashMap在hash冲突过多的情况下转换成树。复制代码

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);}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;}下面这张图说明这个算法的精妙自定义大小以及加载因子的构造方法，判断很简单，注意 tableSizeFor跟之前1.7一样用于找到大于等于initialCapacity的最小的2的幂（initialCapacity如果就是2的幂，则返回的还是这个数）复制代码

1.8 得到Hash值的方法static final int hash(Object key) {    int h;    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}1.7复制代码

区别在于：1.7:将键key 转换成哈希码（hash值）操作 = 使用hashCode() + 4次位运算 + 5次异或运算（9次扰动）

1.8:键key 转换成哈希码（hash值）操作 = 使用hashCode() + 1次位运算 + 1次异或运算（2次扰动）

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node
    
     [] tab; Node
     
       p; int n, i;        // 1. 若哈希表的数组tab为空，则 通过resize() 创建        // 所以，初始化哈希表的时机 = 第1次调用put函数时，即调用resize() 初始化创建        // 关于resize（）的源码分析将在下面讲解扩容时详细分析，此处先跳过        if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;        // 2. 计算插入存储的数组索引i：根据键值key计算的hash值 得到        // 此处的数组下标计算方式 = i = (n - 1) & hash，同JDK 1.7中的indexFor（），上面已详细描述        // 3. 插入时，需判断是否存在Hash冲突：        // 若不存在（即当前table[i] == null），则直接在该数组位置新建节点，插入完毕        // 否则，代表存在Hash冲突，即当前存储位置已存在节点，则依次往下判断：a. 当前位置的key是否与需插入的key相同、b. 判断需插入的数据结构是否为红黑树 or 链表        if ((p = tab[i = (n - 1) & hash]) == null)            tab[i] = newNode(hash, key, value, null);  // newNode(hash, key, value, null)的源码 = new Node<>(hash, key, value, next)        else {            Node
      
        e; K k;            // a. 判断 table[i]的元素的key是否与 需插入的key一样，若相同则 直接用新value 覆盖 旧value            // 判断原则：equals（）            if (p.hash == hash &&                    ((k = p.key) == key || (key != null && key.equals(k))))                e = p;                // b. 继续判断：需插入的数据结构是否为红黑树 or 链表                // 若是红黑树，则直接在树中插入 or 更新键值对            else if (p instanceof TreeNode)                e = ((TreeNode
       
        )p).putTreeVal(this, tab, hash, key, value); ->>分析3            // 若是链表,则在链表中插入 or 更新键值对            // i.  遍历table[i]，判断Key是否已存在：采用equals（） 对比当前遍历节点的key 与 需插入数据的key：若已存在，则直接用新value 覆盖 旧value            // ii. 遍历完毕后仍无发现上述情况，则直接在链表尾部插入数据            // 注：新增节点后，需判断链表长度是否>8（8 = 桶的树化阈值）：若是，则把链表转换为红黑树        else {                for (int binCount = 0; ; ++binCount) {                    // 对于ii：若数组的下1个位置，表示已到表尾也没有找到key值相同节点，则新建节点 = 插入节点                    // 注：此处是从链表尾插入，与JDK 1.7不同（从链表头插入，即永远都是添加到数组的位置，原来数组位置的数据则往后移）                    if ((e = p.next) == null) {                        p.next = newNode(hash, key, value, null);                        // 插入节点后，若链表节点>数阈值，则将链表转换为红黑树                        if (binCount >= TREEIFY_THRESHOLD - 1)                            treeifyBin(tab, hash); // 树化操作                        break;                    }                    // 对于i                    if (e.hash == hash &&                            ((k = e.key) == key || (key != null && key.equals(k))))                        break;                    // 更新p指向下一个节点，继续遍历                    p = e;                }            }            // 对i情况的后续操作：发现key已存在，直接用新value 覆盖 旧value & 返回旧value            if (e != null) {                V oldValue = e.value;                if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e); // 替换旧值时会调用的方法（默认实现为空）                return oldValue;            }        }        ++modCount;        // 插入成功后，判断实际存在的键值对数量size > 最大容量threshold        // 若 > ，则进行扩容 ->>分析4（但单独讲解，请直接跳出该代码块）        if (++size > threshold)            resize();        afterNodeInsertion(evict);// 插入成功时会调用的方法（默认实现为空）        return null;    }    /**     * 作用：向红黑树插入 or 更新数据（键值对）     * 过程：遍历红黑树判断该节点的key是否与需插入的key 相同：     *      a. 若相同，则新value覆盖旧value     *      b. 若不相同，则插入     */    final TreeNode
        
          putTreeVal(HashMap
         
           map, Node
          
           [] tab, int h, K k, V v) { Class
            kc = null; boolean searched = false; TreeNode
           
             root = (parent != null) ? root() : this; for (TreeNode
            
              p = root;;) { int dir, ph; K pk; if ((ph = p.hash) > h) dir = -1; else if (ph < h) dir = 1; else if ((pk = p.key) == k || (k != null && k.equals(pk))) return p; else if ((kc == null && (kc = comparableClassFor(k)) == null) || (dir = compareComparables(kc, k, pk)) == 0) { if (!searched) { TreeNode
             
               q, ch; searched = true; if (((ch = p.left) != null && (q = ch.find(h, k, kc)) != null) || ((ch = p.right) != null && (q = ch.find(h, k, kc)) != null)) return q; } dir = tieBreakOrder(k, pk); } TreeNode
              
                xp = p; if ((p = (dir <= 0) ? p.left : p.right) == null) { Node
               
                 xpn = xp.next; TreeNode
                
                  x = map.newTreeNode(h, k, v, xpn); if (dir <= 0) xp.left = x; else xp.right = x; xp.next = x; x.parent = x.prev = xp; if (xpn != null) ((TreeNode
                 
                  )xpn).prev = x; moveRootToFront(tab, balanceInsertion(root, x)); return null; } } }}复制代码

/** * 该函数有2种使用情况：1.初始化哈希表 2.当前数组容量过小，需扩容 */final Node
    
     [] resize() {    Node
     
      [] oldTab = table; // 扩容前的数组（当前数组）    int oldCap = (oldTab == null) ? 0 : oldTab.length; // 扩容前的数组的容量 = 长度    int oldThr = threshold;// 扩容前的数组的阈值    int newCap, newThr = 0;    // 针对情况2：若扩容前的数组容量超过最大值，则不再扩充    if (oldCap > 0) {        if (oldCap >= MAXIMUM_CAPACITY) {            threshold = Integer.MAX_VALUE;            return oldTab;        }        // 针对情况2：若无超过最大值，就扩充为原来的2倍        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                oldCap >= DEFAULT_INITIAL_CAPACITY)            newThr = oldThr << 1; // 通过右移扩充2倍    }    // 针对情况1：初始化哈希表（采用指定 or 默认值）    else if (oldThr > 0) // initial capacity was placed in threshold        newCap = oldThr;    else {               // zero initial threshold signifies using defaults        newCap = DEFAULT_INITIAL_CAPACITY;        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);    }    // 计算新的resize上限    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
      
       [] newTab = (Node
       
        [])new Node[newCap];    table = newTab;    if (oldTab != null) {        // 把每个bucket都移动到新的buckets中        for (int j = 0; j < oldCap; ++j) {            Node
        
          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
         
          )e).split(this, newTab, j, oldCap); else { // 链表优化重hash的代码块 Node
          
            loHead = null, loTail = null; Node
           
             hiHead = null, hiTail = null; Node
            
              next; do { next = e.next; // 原索引 if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } // 原索引 + oldCap else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); // 原索引放到bucket里 if (loTail != null) { loTail.next = null; newTab[j] = loHead; } // 原索引+oldCap放到bucket里 if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab;}复制代码

public V get(Object key) {    Node
    
      e;    // 1. 计算需获取数据的hash值    // 2. 通过getNode（）获取所查询的数据 ->>分析1    // 3. 获取后，判断数据是否为空    return (e = getNode(hash(key), key)) == null ? null : e.value;}/** * 分析1：getNode(hash(key), key)) */final Node
     
       getNode(int hash, Object key) {    Node
      
       [] tab; Node
       
         first, e; int n; K k;    // 1. 计算存放在数组table中的位置    if ((tab = table) != null && (n = tab.length) > 0 &&            (first = tab[(n - 1) & hash]) != null) {        // 4. 通过该函数，依次在数组、红黑树、链表中查找（通过equals（）判断）        // a. 先在数组中找，若存在，则直接返回        if (first.hash == hash && // always check first node                ((k = first.key) == key || (key != null && key.equals(k))))            return first;        // b. 若数组中没有，则到红黑树中寻找        if ((e = first.next) != null) {            // 在树中get            if (first instanceof TreeNode)                return ((TreeNode
        
         )first).getTreeNode(hash, key);            // c. 若红黑树中也没有，则通过遍历，到链表中寻找            do {                if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                    return e;            } while ((e = e.next) != null);        }    }    return null;}复制代码

如果有错误或者更好的说明，请在下发留言，我会在第一时间回复改正，谢谢！

我不能保证我会在程序员这一行业中一直走下去，但至少此刻，我的信念仍坚定不移。