在java面试中，对于map相关的类是最经常问的，尤其是HashMap。本人在各种面试中都被问到底层原理，所以现在想尽量简洁地总结一下。

HashMap

在Map中HashMap几乎是比问的类，而且大部份类都和他相关。

HashMap是一个存储键值对的线程不安全的容器。目前对于HashMap的大概提问点如下：

• 参数定义
• 数据结构
• 具体函数操作
• 横向对比和纵向对比
• 线程安全

现在根据上面几个方面对HashMap分析。

1. 参数定义

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
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;

上面是HashMap的默认参数，下面逐一讲解。

1. DEFAULT_INITIAL_CAPACITY表示HashMap的table默认大小（数组默认大小）。
2. MAXIMUM_CAPACITY表示HashMap的table的最大容量。
3. DEFAULT_LOAD_FACTOR默认的扩容因子。
4. TREEIFY_THRESHOLD表示链表变为红黑树的阈值。
5. UNTREEIFY_THRESHOLD表示红黑树变为链表的阈值。
6. MIN_TREEIFY_CAPACITY表示最小进行变为进行变为树的table大小阈值。

transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
transient int size;
transient int modCount; 
int threshold;
final float loadFactor;

上面是HashMap对象的成员变量。使用transient修饰不用进行序列化。

1. table是HashMap的容器。
2. entrySet是HashMap的元素集合。
3. modCount是HashMap结构发生改变的次数。（HashMap线程不安全，用来快速判断是否发生线程不安全的情况）在一些遍历函数中会进行比较判断，如果发生改变则抛出ConcurrentModificationException异常。
4. threshold是HashMap需要扩容的容量阈值，根据容量和扩容因子计算。
5. loadFactor是扩容因子。

注意

1. 这里规定容量的大小一定是2的幂次。这里的原因与计算存入Map的元素的位置，以及扩容有关。
2. 链表与红黑树相互转换的阈值大小，与搜索距离有关。

2. 数据结构

HashMap的数据结构为数组+(链表+红黑树)

数组：用来作为容器存储键值对，通过key的hash值确定在数组中的位置。

链表+红黑树：用来处理哈希冲突，使用链式处理哈希冲突。其中当这个节点存储的键值对过多使用链表查询效率（O(n)）过低，红黑树的查询效率（O(log(n))）会快很多。

3. 具体函数

具体函数中问得比较多的是put、get、resize这几个。下面逐一介绍内容。

3.1 put函数

下面是java1.8中的具体写法。各个部分的讲解向下看。

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;
    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;
}

首先，put方法调用的是putVal()方法。

• 其中传入的参数使用hash函数计算hash值（这个下面讲）。

然后，进入putVal方法：

• 判断容器大小是否为null或者0，是的话使用resize函数对容器进行初始化。
• 接下来要把元素插入到Map中。计算当前元素存的位置(n - 1) & hash。
  • 当前位置如果为空，则新建一个节点存入当前位置，使用函数newNode()。
  • 不为空的话，判断判断是否为链表或者红黑树，然后进行插入操作。其中需要判断链的大小（binCount）来决定是否与红黑树相互转换。
    • 这里链表使用尾插法，扩容也是尾插法，这样多线程扩容不会导致死循环。
  • 如果之前key存在if (e != null)，则时更新当前的值，返回之前的值。
• 之前不存在key，增加size和modcount。
• 判断size和threshold的大小，决定是否扩容resize。

最后，返回null。

这里onlyIfAbsent和evict参数暂不介绍，有兴趣可以查看源码注释。

hash元素位置判断

容器的大小为2的幂次原因之一。

• 这样假如容量大小为16，则计算的时候与1 0000二进制减1的0 1111，与操作效率高。

红黑树和链表转换阈值为6和8

源码的注释解释：

• 红黑树和链表之前是空间和时间上的权衡，TreeNodes占用空间是普通Nodes的两倍。
• 当hashcode函数性能较好的情况下，红黑树用到的情况较少。
• 理想的情况下，bin符合泊松分布(Poisson_distribution)，一个bin中链表长度达到8个元素的概率为0.00000006

下面是网络上关于查找长度的解释。

阈值8的原因：

• 红黑树的平均查找长度是log(n)，如果长度为8，平均查找长度为log(8)=3。
• 链表的平均查找长度为n/2，当长度为8时，平均查找长度为8/2=4

这才有转换成树的必要。

阈值6的原因：

• 链表长度如果是小于等于6，6/2=3
• 红黑树为log(6)=2.6

虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短。

3.2 get函数

下面是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 &&
        (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) {
            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;
}

首先，这里调用的get方法，其中使用getNode方法。

• 这里也使用了hash函数 然后，介绍getNode方法。
• 这里判断容器不为空，找到hash值对应的位置。
• 判断第一个点是否是要查找的元素。
• 判断是否是红黑树，如果是则调用红黑树节点的getTreeNode方法。
• 如果是链表，则使用do{...}while();遍历查找。

最后，都不符合返回null。

3.3 resize函数

下面是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;
            }
            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);
        }
        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
                        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;
    }

这部分比较长，可以分为两个部分。

第一个部分：计算新的容量和新的容量阈值，然后申请新的内存空间。

• 如果容量大于等于最大容量，则不扩容使用最大容量，直接返回。
• 不是则成倍扩容（向左位移1），或者使用默认值初始化容器。
• 申请新的内存空间。
• 替换旧容器。

第二个部分：把旧的容器内容移动到新的容器。

• 遍历旧容器。判断节点是一个的话直接移动。
• 判断为红黑树的话，使用树的split函数划分到新的容器。
• 判断是链表的话，把原来的链表分为两个部分，分到新的容器中（新的位置这里直接加上就容器大小oldCap），这里判断使用(e.hash & oldCap)，这个原理等下介绍。

最后，返回新的容器。

计算使用oldCap的原因

容器大小为2的幂次原因之二。

• 假如容量为16，二进制位1 0000。新的容器大小的二进制为10 0000，与hash值进行模运算的时候，计算的是后5位。
• 旧容器上hash值的后4位的值是相同的，扩容计算的时候只要对旧的位置上的所有元素计算hash值的第5位上的值。
• 通过和oldCap与操作判断第五位位置上的hash值可以分为两个部分。这个位置为0在原来位置，为1则在原来位置加上oldCap的位置上。

3.4 hash函数

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

这里使用(h >>> 16)为的是，使得高位的信息包含在hash值中。

4. 横向对比和纵向对比

横向对比

需要进行横向对比的类为：

• HashTable；这个是一个线程安全的类，方法使用synchronized修饰，但是并发效率低。容量为素数减少碰撞，取模效率低。
• LinkedHashMap：继承HashMap，保存插入顺序。其中代码题LRUCoach可以继承使用leetcode链接
• ConcurrentHashMap：线程安全的类，并发效率高，具体之后等有时间写文章介绍。
• WeakHashMap：使用了弱引用的HashMap，对键值不存在引用的时候，如果GC则回收。ThreadLocal中使用到，具体之后等有时间写文章介绍。

横向对比

纵向对比的话，就是和1.7相比较：

• JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法。
• JDK1.8加入红黑树，增加查询效率。
• 扩容后数据存储位置的计算方式也不一样。

5. 线程安全

HashMap是个线程不安全的类。可以使用ConcurrentHashMap或者HashTable。

1. 相比1.7使用头插法解决了死循环问题。
2. 在put等修改操作上会存在多线程覆盖的情况。

这里讲下死循环的原因：因为1.7中使用头插法扩容，这样链表扩容后为逆序。当有多个线程进行扩容的时候，第一个线程把链表逆序，第二个线程指向的头结点变为尾结点，然后扩容这样会变成环。

本篇文章参考

• 1.8源码。
• HashMap多线程死循环问题