概述

HashMap是基于哈希表的Map接口实现的一种存储key、value的数据结构，提供了所有可选的映射操作，且键值允许null的存在，不保证数据映射的顺序，也不能保证顺序在一段时间内保持不变

底层结构

jdk1.7：数组+链表

jdk1.8：数组+链表+红黑树

哈希冲突

从上文图中显而易见，hashMap用的拉链法来解决哈希冲突的，也就是当一个数据计算出来的hash值已经在table数组中存在的话，就以链表的结构追加在后面

1. 当链表长度>=8且数组长度>=64时，会把链表转化为红黑树
2. 当链表长度>=8，当数组长度<64时，会优先进行扩容，而不是转化为红黑树
3. 当红黑树节点数<=6时，自动转化为链表

源码解析

put()

put流程

根据插入数据的key进行hash计算，得到在table数组将要插入的下标索引i，若i号下标为null，则直接插入，若不为null，就要进行「哈希冲突处理」，依次去查找table[i]所挂载的结构数据，也就是遍历链表或红黑树，若key已存在就进行覆盖操作，否则就要找到合适的位置进行插入，链表就是找到尾巴元素，到了尾巴要判断链表和数组的长度看是否要进行扩容或转换结构，若符合条件则先进行扩容或转换结构之后再插入元素

1. 当链表长度>=8且数组长度>=64时，会把链表转化为红黑树
2. 当链表长度>=8，当数组长度<64时，会优先进行扩容，而不是转化为红黑树

    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;
        //判读table是否为空，为空则执行resize()扩容
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //若hash值对应下标的table没有数据，则直接构造node插入
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //若key已存在，则覆盖原数据
            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);
                        //若链表长度>=8，则进行扩容或转化为红黑树，并插入
                        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;
    }

resize()扩容

数组长度扩展为原来的两倍，再遍历原的数组，把所有的节点重新hash到新数组中

1. jdk1.7 ：遍历所有的节点，依次通过hash函数计算新的下标，再插入到新数组的链表中。缺点：每个节点都需要进行一次求余计算；插入新数组采用的是头插法，在多线程环境下会形成链表环
2. jdk1.8：控制数组的长度始终是2的整数次幂，每次扩展数组都是原来的2倍，key在新数组的hash结果只有两种：在原来的位置，或者在原来位置+原数组长度

get()

根据要查找的key计算hash值得到在table数组中的下标索引i，先check table[i]是否为目标值，若是就直接返回，不是就依次查找table[i]挂载的结构中的元素校验是否符合目标值

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(key)) == null ? null : e.value;
    }

   
    final Node<K,V> getNode(Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n, hash; K k;
        //check table不为空，根据key计算得到hash值即为在table数据中的下标i
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & (hash = hash(key))]) != null) {
            //若table[i]的key和目标值相同，则找到了
            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;
    }

常见问题

为什么jdk1.8需要加上红黑树的结构？

首先我们明确了无论是链表还是链表+红黑树都是为了解决哈希冲突的问题，那么从上文的get操作能看到，如果table[i]不是目标元素，就需要依次循环遍历table[i]挂载的结构，挨个对比结点数据是否为目标数据，链表的查询操作的时间复杂度是O(n)，所以数据量越大冲突的几率就越大那么查询的效率就越慢，而红黑树的查找时间复杂度是O(logn)，加上红黑树就是为了提高查询的速度

线程不安全（Fail-Fast机制）

举例：两个线程同时put，A线程在执行真正的插入操作时时间片到了，A线程挂起，然后B线程进来执行put操作，B线程结束后，A被调度，A的插入操作可能会把B刚刚插入的元素覆盖掉

1. 如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这个结果是通过modCount字段实现的，顾名思义就是修改次数，每次对HashMap的修改都会增加这个值，而在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount
2. 在迭代过程中，判断modCount跟expectedModCount是否相等，如果不相等就表示已经有其他线程修改了Map