Jdk 1.8

  1. 数据结构

    1.8的版本的HashMap采用数组+链表+红黑树的数据结构来存储数据,还是通过hash & (tab.length - 1)来确定在数组的位置,不过在数据的存储方面加了一个红黑树,当链表的大于等于8时,并且table的长度大于等于64时,就把这个链树化,不然还是扩容.增加红黑树,是为了提高查找节点的时间.结构如下图所示.

    HashMap 源码浅析 1.8

  2. 基本成员变量
    capacity 容量

    /**
     * 初始容量
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    max_capacity 最大容量

    /**
     * 最大容量
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    loadFactor 负载因子

    /**
     * 负载因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    treeify_threshold 树化(转换为红黑树)的阈值

    // 链表转为红黑树的阈值,第9个节点
    static final int TREEIFY_THRESHOLD = 8; 

    untreeify_threshold 转换为链表的阈值

    // 红黑树转为链表的阈值,6个节点转移
    static final int UNTREEIFY_THRESHOLD = 6;

    min_treeify_capacity 树化的最小容量

    // 转红黑树时,table的最小长度
    static final int MIN_TREEIFY_CAPACITY = 64;

    node 链表

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

    TreeNode 红黑树

    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);
        }
  3. 构造方法
    有参构造 (和1.7一样)
    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);
    }

    无参构造(和1.7一样)

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
  4. 基本方法
    Put()方法
    执行流程:
    (1) 判断当前table有没有初始化,没有就调用resize()方法初始化.(resize方法既是扩容也是初始化)
    (2) 判断算出的位置i处有没有值,没有值,创建一个新的node,插入i位置.
    (3) 当前i位置有值,判断头结点的hash和key是否和传入的key和hash相等,相等则记录这个e.
    (4) 与头节点的key和hash不同,判断节点是否是树节点,如果是,调用树节点的插入方法putTreeVal()方法.(占时不了解红黑树的底层方法实现逻辑,待续).
    (5) 不是树结构,那证明是链表结构,遍历链表结构,并记录链表长度binCount.主要做了两步,(1)在链表里找到和传入的key和hash相等的基点,并记录,(2) 没有找到,创建一个节点,插入链表的尾部,并判断链表长度有没有大于等于8,如果是就调treeifyBin方法决定是否需要树化.
    (6) 判断前面记录的e节点是否为空,不为空证明找到了相同的基点,那就替换value,返回oldValue.
    (7) 整个插入流程已经结束,接下来要判断是否需要扩容,如果(++size > threshold)满足,那么就调用扩容方法resize();

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    
    /**
     * 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) // table为null,table的length为0,table还没有初始化
            n = (tab = resize()).length; //调用扩容方法,初始化table
        if ((p = tab[i = (n - 1) & hash]) == null) //table{[i] 没有值,直接插入
            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)))) // 找到了相同的key
                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); //设置当前节点为为p的next
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 如果节点长度大于等于了8,就调用treeifyBin方法
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k)))) // 找到了相同的key
                        // 此时break,返回的是e.key与传入的key相等的e,以便下面进行替换
                        break;
                    p = e;
                }
            }
            // e != null 说明前面的遍历找到了相同的key,下面就行替换,返回旧值
            if (e != null) { // existing mapping for key //
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null) // onlyIfAbsent默认是false
                    e.value = value; // 替换value
                afterNodeAccess(e);
                return oldValue; // 返回旧的value
            }
        }
        ++modCount;
        //  当前值大于阈值,进行扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

    resize()方法(初始化和扩容都是创建新的table)
    解释为什么在新table的位置没有重新计算,而是根据(e.hash & oldCap) == 0,等于0就是在原位置,不等于0时,就是newtable[原位置+oldCap] ,如下图.
    table长度我们以16为例,hash值我们以484和30为例,我们发现484&16=0,30&16=30,我们发现一个区别就是他们的他们的低5位一个是0,一个是1.
    HashMap 源码浅析 1.8
    我们让低5位是0的484,分别&上(16-1)和(32-1),结论是位置没有发生变化,所以说如果低5位是0,那么扩容前和扩容后位置不变.
    HashMap 源码浅析 1.8
    我们让低5位是1的30,分别&上(16-1)和(32-1),结论是位置发生变化,所以说如果低5位是1,那么新位置就是原来位置+oldCap.
    HashMap 源码浅析 1.8
    其实我们发现(e.hash & oldCap) == 0 只是为了证明低5位是0还是1,这是为什么了,其实是和(16-1)和(32-1)有着密切的关系,15二进制是1111,31是11111,我们发现不管哪个数&上15或者31都是这个数低4位或者低5位本身,所以e.hash如果低5位0,那其实都是&1111,因为低5位是0&运算下还是0,如果e.hash的低5位是1,那么和0相比就是低5位会变成1,所以需要加上这个多的位置的值oldCap.

    /**
     * 扩容
     * @return
     */
    final Node<K,V>[] resize() {
        // 旧table
        Node<K,V>[] oldTab = table;
        // 旧的table长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 旧的阈值
        int oldThr = threshold;
        int newCap, newThr = 0;
        //  证明就table,已经被初始化了
        if (oldCap > 0) {
            // 如果旧的table大于做大值,阈值就设置为Internet的最大值,返回
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 给newCap赋值 newCap = oldCap << 1 (* 2^1) < MAXIMUM_CAPACITY(1 << 30)
            // oldCap >= 16 证明已经初始化过了,现在是扩容(假如oldCap就是16)
            // 新阈值 newThr = (oldThr = threshold) = 12 << 1(12 * 2^1)
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold // 新的阈值
        }
        // 这种情况是table还没有初始化
        // oldThr >0 是因为在有参构造里面会把cap赋值给threshold
        else if (oldThr > 0) // initial capacity was placed in threshold
            // 容量就是oldThr
            newCap = oldThr;
        // 无参构造,容量和阈值都使用默认
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // newThr=0证明使用的是有参构造,容量有值,阈值没有值
        // 所以初始化阈值
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                    (int)ft : Integer.MAX_VALUE);
        }
    
        /** 上面属于table参数准备部分,分为初始化或者扩容 */
    
        // 新的阈值
        threshold = newThr;
        // 创建新的table
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            // 开始遍历旧的table,进行数据迁移
            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 表示位置不变 hi表示位置是原来的位置+oldCap
                        // 是通过(e.hash & oldCap) == 0 这句话来判断的
                        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) // 第一次循环 tail 为null,所以头和尾都是 e
                                    loHead = e;  // 头部是当前的e
                                else             // 接下来的循环tail不为null
                                    loTail.next = e; // loTail 是上一次满足if的e
                                                     // e 是这一次满足if的e
                                                     // 所以loTail.next = e的目的就是,上一次满足if的e指向下一次满足if的e
                                                     // 代码就是loTail.next = e
                                loTail = e;  // 每次循环尾部就是当前节点
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 位置不变还是j
                        if (loTail != null) {
                            loTail.next = null; // 尾部节点的next设置为null
                            newTab[j] = loHead; // 设置头结点指向table[j] (第一次循环时,head=tail,接下来循环给tail追加节点)
                        }
                        // 位置变化,是 j+oldCap
                        if (hiTail != null) {
                            hiTail.next = null; 
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

    get()方法

    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;
        if ((tab = table) != null && (n = tab.length) > 0 && // table不是null,table的长度大于0
                (first = tab[(n - 1) & hash]) != null) { // ,根据可以取得第一个node不为空
            if (first.hash == hash && // always check first node  对比第一个hash和当前值的hash是否一样
                    ((k = first.key) == key || (key != null && key.equals(k))))
                return first; // 等于第一个,返回
            if ((e = first.next) != null) { // 向下遍历,next不等于空
                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; //  没有找到,返回null
    }
  5. 总结

    1.8 在数据结构方面加入了红黑树,提升了查询的性能,在链表插入方面是先插入的在前面,而在1.7先插入的在后面.在扩容方面,没有重新计算hash,这算是一大改变,还有就是在扩容后链表的顺序没有改变.红黑树方面占时不太了解.
    前面的1.7 HashMap和1.8我们都讲了loadFactor负载因子,来解释下这个的作用,loadFactor越小,说明存储的元素就少,因为HashMap存在hash冲突,所以存的元素越少,冲突就越小,查询的效率就的到了提升,但是存的元素少了,就浪费了容量,所以这是一种以空间换时间的做法.loadFactor越大,说明存的元素就越多,数据多了hash冲突就会提高,所以查询时间就会提高,这是一种以时间换空间的做法.所以具体是需要时间还是空间根据自己的功能来确定.