HashMap源码分析

HashMap

一个数字左移一次就是乘2 左移2次就是乘两次2

右移一次就是除以2

属性

//哈希表结构中数组的名字
transient Node<K,V>[] table;

transient Set<Map.Entry<K,V>> entrySet;

transient int size;

transient int modCount;

//（容量 * 负载系数）元素个数达到这个值就要扩容
int threshold;

final float loadFactor;

静态常量

//底层数组的默认初始化长度
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

//最大长度
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;

//链表转红黑树所需达到数组长度
static final int MIN_TREEIFY_CAPACITY = 64;

存储结构

//链表中的键值对对象
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;//键的哈希值
    final K key;
    V value;
    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;
    }

//红黑树中的键值对对象
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;  // needed to unlink next upon deletion
    boolean red;  //节点颜色
    TreeNode(int hash, K key, V val, Node<K,V> next) {
        super(hash, key, val, next);
    }

构造方法

public HashMap() {
    //指定加载因子为0.75
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

//指定容量和加载因子
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    //如果设置的容量超过了最大值，自动置为最大值
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    //加载因子不可小于等于0，或者非数字
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    //根据指定容量初始化扩容阈值
    this.threshold = tableSizeFor(initialCapacity);
}
//获取一个既大于 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);
}

不管是有参构造还是无参构造底层都没有初始化table数组

添加

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

/**
 * 根据键计算的哈希值
 * 键
 * 值
 * 是否保留重复的元素，如果为false，将会覆盖
 *
 * 返回值：被覆盖元素的值，如果没有被覆盖，返回null
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; //定义一个局部变量，用来记录哈希表中数组的地址值（成员变量定义在堆中，每次使用需要去堆中找，通过局部变量记录，可避免，从而提高效率）
    
    Node<K,V> p; //临时的第三方变量，用来记录键值对地址值
    
    int n, i; //n :表示当前数组的长度，i：表示索引
    
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //将要存入位置存在的元素赋值给p   [i = (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;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            //如果键相同，将p赋值给e，随后将值覆盖掉，并返回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) {
                //遍历到链表的最后一个节点  e代表链表中遍历到的当前元素
                if ((e = p.next) == null) {
                    //创建新的节点，将其挂在链表最后一个节点后面
                    p.next = newNode(hash, key, value, null);
                    //判断链表长度是否超过8
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        //treeifyBin底层还会继续判断数组长度是否大于等于64，都满足的话转成红黑树
                        treeifyBin(tab, hash);
                    break;
                }
                //如果遍历的过程中发现，有与要添加的元素的键相同的节点，停止遍历，随后将其覆盖
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                //p代表链表遍历的上一个元素
                p = e;
            }
        }
        //如果e为null，表示不需要覆盖任何元素
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            //如果老的值为null，或者不保留重复元素，将其覆盖
            if (!onlyIfAbsent || oldValue == null)
                //所以，覆盖的不是键值对，原来的键值对还在，覆盖的只是值
                e.value = value;
            afterNodeAccess(e);//和LinkedHashMap相关
            return oldValue;
        }
    }
    ++modCount;
    //判断是否到达扩容门槛
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);//和LinkedHashMap相关
    //当前没有覆盖任何元素，返回null
    return null;
}

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;
    //判断是要扩容还是初始化，容量大于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
    }
    //要初始化，此时阈值大于0，表示创建对象时调用的是有参构造
    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);
    }
    //当扩容阈值为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 = newTab;
    //判断是不是扩容的，如果是初始化的不需要执行if中的代码
    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;
                    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;
}

treeifyBin方法

链表转红黑树

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; 
    Node<K,V> e;
    //当数组等于null，或长度不到64时，不执行链表转红黑树，执行扩容
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    //判断当前索引元素是否为null
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        //红黑树的头结点和尾结点
        TreeNode<K,V> hd = null, tl = null;
        do {
            //添加节点e进TreeNode
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);//判断下一个节点是否为null
        
        //上述内容只是把Node转成TreeNode，单链表改成双向链表
        //将根节点放入数组位置，并判断是否为null
        if ((tab[index] = hd) != null)
            hd.treeify(tab);//转成红黑树
    }
}

思考

• HashMap底层数组长度为何总是2的n次方

  HashMap会根据用户指定的初始容量获取一个既大于 cap 又最接近cap的 2的整数次幂数值作为阈值

  作用：

  • 使分布均匀，减少冲突
  • 这样h & length - 1 就相当于 h % length ，在速度和效率上比直接取模快

• JDK1.8中HashMap的改变

  • 之前是数组+链表 ，8之后是数组+链表+红黑树
  • 之前插入新的元素是将新元素插入数组，这个位置的老元素挂在下面，现在是将新元素挂在老元素下面
  • Node替换了原来的Entry
  • 8对rehash算法进行了优化

• hash的实现
  如果key == null 返回0，key的hashCode值的高16位异或低16位
  把高低位都利用起来，减少hash冲突