HashMap深度剖析，面试用

HashMap几个比较重要的属性

int threshold;  // 所能容纳的key-value对极限，threshold = length * Load factor 
final float loadFactor;    // 负载因子，默认0.75，不建议修改
int modCount;  //用来记录HashMap内部结构发生变化的次数
int size;   //hashmap的长度，注意和table长度，threshold区别

HashMap几个重要特征

• threshold达到阈值时，会自动扩容resize()，大小为原来2倍
• 哈希桶中，Node链表长度 >=8 时会自动演化为红黑树
• 据键的hashCode值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。
• HashMap最多只允许一条记录的键为null，允许多条记录的值为null。
• HashMap非线程安全，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。
• 要满足线程安全，用 Collections的synchronizedMap方法进行包装，或者使用ConcurrentHashMap

HashMap如何确定哈希桶数组的索引位置

/*
 * 代码阅读
 * 计算key的hashCode()得到32位hash_1, hash_1右移16位得到hash_2, hash_1 ^ hash_2 = hash_3
 * 返回hash_3，最后在put方法里面使用（n-1）& hash_3得到索引位置。
 * 神奇现象：当length总是2的n次方时，h&(length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。
 */
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

• hashCode()计算流程示意图
  

HashMap putVal()方法剖析

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)
            //如果初始大小为0，先进行扩容，再将扩容好的hashmap赋给tab
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            //第一个结点没有值，直接新建一个node，并且已经将第一个节点值赋给p，后面p就有值了
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; //可以移动的节点，遍历的过程需要操作e
            K k;
            if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
                //第一个节点和新值value相等，则将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);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //遍历过程中，如果发现某个节点和即将存入相等，则跳出循环，便于后续进行新旧值更换
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                //开始赋值，若e这个指针对应位置为空||强制新旧值替换，则将value赋进去
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

• 根据源码可看出，put方法返回值为null 或者旧值，发生新值替换旧值时则返回旧值
• put流程语言描述
  • 1.先判断哈希桶数组是否初始化，未初始化则进行初始化
  • 2.根据新对象的key值进行hash，找到哈希桶的位置。
  • 3.判断桶的第一个节点是否为空，为空则将新对象作为第一个节点存放
  • 4.第一个节点不为空，判断第一个节点与新对象是否相等，相等则将指针指向当前节点（第一个）
  • 5.判断第一个节点是否为红黑树节点，并且和新对象不相等，去红黑树中寻找，找到的话，将指针指向目标节点。
  • 6.第一个节点位于链表的中，并且和新对象不相等，则依次遍历链表，遍历过程中找到与新对象相等的节点，则将指针指向这个节点，若遍历过程中发现节点数量>=8，则将链表转为红黑树
  • 7.若指针节点不为空，替换指针节点的值为新对象。
  • 8.增加modCount, 若size > 最大容纳极限，则扩容。

get方法剖析

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
// 获取hash值
static final int hash(Object key) {
    int h;
    // 拿到key的hash值后与其五符号右移16位取与
    // 通过这种方式，让高位数据与低位数据进行异或，以此加大低位信息的随机性，变相的让高位数据参与到计算中。
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

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 &&
        (first = tab[(n - 1) & hash]) != null) {//先找到桶组索引，然后赋给第一个结点
        // 判断桶中第一项(数组元素)相等
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 桶中不止一个结点，且不是第一个结点
        if ((e = first.next) != null) {
            // 是否是红黑树，是的话调用getTreeNode方法
            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;
}

resize()方法

void resize(int newCapacity) {   //传入新的容量
    Entry[] oldTable = table;    //引用扩容前的Entry数组
    int oldCapacity = oldTable.length;         
    if (oldCapacity == MAXIMUM_CAPACITY) {  //扩容前的数组大小如果已经达到最大(2^30)了
    threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
      return;
    }
   
    Entry[] newTable = new Entry[newCapacity];  //初始化一个新的Entry数组
    transfer(newTable);                         //！！将数据转移到新的Entry数组里
    table = newTable;                           //HashMap的table属性引用新的Entry数组
    threshold = (int)(newCapacity * loadFactor);//修改阈值
 }