【jdk1.8】HashMap源码分析

类的继承关系

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

其中，Map接口中规定了map类的常用方法。比如get(Object): V，put(K, V): V，isEmpty(): boolean，size(): int，remove(Objec): V 等。
Cloneable与Serializable是标识接口。

类的成员变量

    /**
     * 缺省的初始容量（数组长度），必须是2的幂。
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * 最大的容量， 用来修正如果有更大的值被设定。必须是2的幂，而且小于等于1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 缺省的填充因子，如果当前size大于当前容量（数组长度）乘以填充因子就需要扩容，扩为原来容量的两倍。
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 当bin中的数量大于此值的时候，就要将list转成红黑树。
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * 如果经过resize或者元素被remove，而使得一个bin中的元素数量少于这个值之后就应该红黑树转成list了。
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**树的最小的容量，至少是 4 × TREEIFY_THRESHOLD = 32 然后为了避免(resizing 和 treeification thresholds) 设置成64
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

    /**
     * 哈希数组，总是2的幂。
     */
    transient Node<K,V>[] table;

    /**
     * 存放具体元素的集。
     */
    transient Set<Map.Entry<K,V>> entrySet;

    /**
     * 在整个map中存数的key-value对的数目。
     */
    transient int size;

    /**
     * 整个hashmap进行结构调整的次数。用来检测并发修改异常（ConcurrentModificationException）。
     */
    transient int modCount;

    /**
     * 当size达到这个值时将要被resize。(threshold = capacity * load factor)
     */
    int threshold;

    /**
     * 哈希数组的填充因子。
     */
    final float loadFactor;

类的构造函数

    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)方法返回大于给定cap的最小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;
    }

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

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

其中final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict)函数就是将m中的每个元素放入现在的hashmap中。

hashmap实现原理图

图片来源：http://www.cnblogs.com/leesf456/p/5242233.html

重要的方法

static final int hash(Object key)

注意，hashmap的hash值是由此方法计算的。而hashtable的hash值直接使用key.hashCode()。

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

public V put(K key, V value)

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

    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为空指针或者table长度为零，则resize扩容。
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //如果数组中该哈希位为空，也就是该bin中还没有元素，则生成新节点放入该位置。此时还是在数组中。
        //注意使用 (n - 1) & hash 来进行散列避免使用取余(%)的开销。 
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            //若数组中该哈希位已经有元素。
            Node<K,V> e; K k;
            //如果将插入的key的哈希值和该位置的key的哈希值相等，并且key也相等。（相当于插入重复元素了）
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //用e来记录该节点
                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);
                        //插完之后如果该bin中的节点数过大，则应该将链表转成树形结构
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        //put成功，跳出
                        break;
                    }
                    //如果在链表中找到了重复的key值
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    //与循环刚开始的 e = p.next 配合来遍历链表
                    p = e;
                }
            }
            //找到了重复的key
            if (e != null) { // existing mapping for key
                //保存旧值
                V oldValue = e.value;
                //若非仅不存在则插入
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //让LinkedHashMap回调
                afterNodeAccess(e);
                //返回旧值
                return oldValue;
            }
        }
        //结构修改次数增加
        ++modCount;
        //如果节点数过多，则扩容
        if (++size > threshold)
            resize();
        //让LinkedHashMap回调
        afterNodeInsertion(evict);
        return null;
    }

        final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                                       int h, K k, V v) {
            Class<?> kc = null;
            boolean searched = false;
            //得到根节点
            TreeNode<K,V> root = (parent != null) ? root() : this;
            //遍历树的节点
            for (TreeNode<K,V> p = root;;) {
                int dir, ph; K pk;
                //待插入节点key的哈希值比当前key的哈希值小，方向为左子树
                if ((ph = p.hash) > h)
                    dir = -1;
                //大于当前，右子树
                else if (ph < h)
                    dir = 1;
                //找到重复的key，返回当前节点
                else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
                    return p;
                //若hash值等于当前，而且调用compareComparables方法还是返回相等
                else if ((kc == null &&
                          (kc = comparableClassFor(k)) == null) ||
                         (dir = compareComparables(kc, k, pk)) == 0) {
                    //还未搜索过
                    if (!searched) {
                        TreeNode<K,V> q, ch;
                        //只搜索一次
                        searched = true;
                        //在根节点为ch的子树中寻找key，找到则返回
                        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;
                    }
                    //方法用尽，只能———比类名和System.identityHashCode值
                    dir = tieBreakOrder(k, pk);
                }
                TreeNode<K,V> xp = p;
                //根据direction选择左右子树，找到叶子节点进行插入
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    Node<K,V> xpn = xp.next;
                    TreeNode<K,V> 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<K,V>)xpn).prev = x;
                    moveRootToFront(tab, balanceInsertion(root, x));
                    return null;
                }
            }
        }

public V get(Object key)

    public V get(Object key) {
        Node<K,V> e;
        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;
        //如果bin中的第一个节点不为空
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //如果第一个key就已经是了，就返回
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            //不然，如果下一个节点非空
            if ((e = first.next) != null) {
                //如果是树的节点类型，则在树里面找
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                //否则遍历整个链表
                do {
                    //找到则返回
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

        final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
            TreeNode<K,V> p = this;
            do {
                int ph, dir; K pk;
                TreeNode<K,V> pl = p.left, pr = p.right, q;
                //待寻找节点hash值比当前节点key的hash值小
                if ((ph = p.hash) > h)
                    //在左子树中找
                    p = pl;
                //若大，则在右子树中找
                else if (ph < h)
                    p = pr;
                //若相等做进一步判断
                //如果就是当前key，则返回当前节点
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
                //若相等，还不是当前节点
                //左子树为空，只能在右子树中找
                else if (pl == null)
                    p = pr;
                //只能在右子树中找
                else if (pr == null)
                    p = pl;
                //当相等，还不是当前节点，而且当前节点左右子树都不空
                //若调用compareComparables方法能判断出下一步的寻找方向
                else if ((kc != null ||
                          (kc = comparableClassFor(k)) != null) &&
                         (dir = compareComparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;
                //若还是不行的话，则在右子树中找，找到返回
                else if ((q = pr.find(h, k, kc)) != null)
                    return q;
                //上面所有步骤都不行的话，就让无论如何都在左子树中找吧
                else
                    p = pl;
            } while (p != null);
            //没辙了，返回空
            return null;
        }

这么重要怎能没有resize呢？final Node<K,V>[] resize()

    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) {
                //更改完阈值之后就返回
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //最一般的情况，新的数组长度为老数组长度的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                //阈值也翻倍
                newThr = oldThr << 1; // double threshold
        }
        //如果以前数组里没东西，但是以前阈值是被赋值过的
        else if (oldThr > 0) // initial capacity was placed in threshold
            //则初始容量被赋值为阈值
            newCap = oldThr;
        //如果数组也未分贝，阈值也未曾赋值
        //使用缺省值（如使用HashMap()构造函数，之后再插入一个元素会调用resize函数，会进入这一步）
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //新阈值为零
        if (newThr == 0) {
            //阈值为 capacity × loadFactor
            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;
                //当前下标的元素不为空
                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
                        //lo == low, hi == high。由于数组翻倍了，相当于低位是老的数组，高位是新的一半。
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            //将同一bin中的元素按照hash值扩容之后新容量的高位的末位是否为0来判断是否分割，完成rehash
                            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;
    }

关于上面所说的“高位”和“低位”

图片来源同上。

References

JDK1.8源码分析之HashMap（一）