HashMap经典问题分析，面试必备

HashMap分析

基本参数

//序列号
private static final long serialVersionUID = 362498820763181265L;
/**
 * The default initial capacity - MUST be a power of two.
 	默认初始容量为16     且必须为2的幂。
 */
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.
 	最大容量，如果隐式指定更高的值，则使用
	由两个带有参数的构造函数组成。
	最大容量：2的30次方：1.073741824E9
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * The load factor used when none specified in constructor.
 加载因子 构造函数中未指定时使用的负载系数。
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 *
 红黑树化的阈值  当链表长度大于8就进行转化
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 退化成链表的阈值  当红黑树的长度小于6就会退化成链表
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 哈希表的长度达到64（注意不是size）就进行树化  
 */
static final int MIN_TREEIFY_CAPACITY = 64;

基本结构

hashmap的结构是哈希桶，也就是数组加链表；

当链表长度大于8并且哈希表的长度到达64就会把链表转化为红黑树；

其中链表的数据都存在数组中

添加方法put()

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

调用put（K,V）方法存放一个键值对对象，调用了putVal()方法和hash()方法，先来看hash（)方法

hash()的源码

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

hash方法将key进行判断，如果为空则返回0；否则则返回(h = key.hashCode()) ^ (h >>> 16)

(h = key.hashCode()) ^ (h >>> 16)称为扰乱函数，目的是为了让hashCode值更加的分散

假定添加的key计算出来的hashcode二进制表现如下，与本身右移16位进行^运算(相同为0 不同为1)

计算出来的二进制结果如下 其在putVal()方法终会被用到

putVal()源码

其中putVal源码 重点看取存放位置的索引这行代码：if ((p = tab[i = (n - 1) & hash]) == null)

tab[i = (n - 1) & hash] 这里面实际就是计算i（索引）的方法，也称为路由寻址，通过key计算索引决定放在哪个哈希桶（数组）上

n代表数组的长度 默认长度为16 n-1 = 15

15的二进制为1111 高位取零 与前面计算的hash值进行&运算 这样算出来的值一定在n的长度范围之内

/**
     * Implements Map.put and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    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)
            n = (tab = resize()).length;
        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))))
                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
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

那么问题来了

1.为什么保证长度必须是2的幂次

首先计算key.hashcode时为什么要与本身右移16位进行^运算呢?

因为hashcode()计算出来的值非常大，低16位可能很多0，高16位和低16位运算后的可以让它结果更加分散，再看下图

假如长度为17 那么-1结果16 2进制为1 0000 后四位进行&操作时结果必定为0

只有1这个位置的元素会发生改变 只会 那么添加元素时放在哈希表的位置不够分散

因此要求长度是2的幂次就是为了存放元素的时候能够均匀的分布在每个索引上

但是即使这样还是会出现哈希冲突的现象，因为hashcode()计算索引时即使不同的元素也有可能计算出来的值也可能相等

2.那么怎么解决哈希冲突（哈希碰撞呢）？

hashmap是通过拉链法解决，也就是形成链表的结构

但是当链表长度到8，数组长度到64，就会把链表进行树化，转化为红黑树

删除元素时，当链表长度变为6，又会将红黑树退化成链表

3.那么为什么阈值是8呢

• 0: 0.60653066
• 1: 0.30326533
• 2: 0.07581633
• 3: 0.01263606
• 4: 0.00157952
• 5: 0.00015795
• 6: 0.00001316
• 7: 0.00000094
• 8: 0.00000006
• more: less than 1 in ten million

前面概率是源码的部分注释

这里涉及到泊松分布 当链表的长度能到8的概率是 0.00000006 大于8的话达到千万分之1 非常的小，所以用8作为阈值

resize()扩容方法

这里是部分源码 扩容机制就是左移一位 也就是原来的2倍

if (oldCap > 0) {
    if (oldCap >= MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return oldTab;
    }
    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;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }

问题来了

4.什么时候会扩容呢

Capacity：HashMap当前⻓度。 LoadFactor：负载因⼦，默认值0.75f。

假如长度为16 当存进第12个元素时不会如何，当存第13个元素时就会进行resize(),也就是扩容

5.那么扩容如何进行

首先会创建一个新的Entry数组，为原来数组的两倍

然后再将以前的元素resize(),重新放入到新的数组中

由于 tab[i = (n - 1) & hash] ，n的长度发生改变，所以计算索引的值也会不同

6.拉链法造成的问题（头插法，尾插法）

因为1.7之前使用头插法，会让resize出现环形链表的情况

扩容前：

扩容后：

Java7在多线程操作HashMap时可能引起死循环，原因是扩容转移后前后链表顺序倒置，在转移过程中

修改了原来链表中节点的引⽤关系。

Java8在同样的前提下并不会引起死循环，原因是扩容转移后前后链表顺序不变，保持之前节点的引⽤

关系。

7.为什么选择红黑树而不用平衡二叉树

最优解

因为平衡二叉树要保证平衡不断自旋，在添加删除的时候则会十分的耗费时间。

而红黑树不用保证绝对的平衡，虽然相对于查询来讲可能会慢一点，因为树高度的问题，但是添加删除不会这么耗时，因此是个最优解。

8.线程安全问题

无法保证多线程情况下put 和get的值相同，最好使用concurenthashmap