HashMap的使用、底层结构、源码分析、常见面试题分析

一、HashMap

1、介绍

HashMap是基于哈希表的Map接口的非同步实现（Hashtable跟HashMap很像，唯一的区别是Hashtalbe中的方法是线程安全的，也就是同步的）。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。主要就是映射的用途，也就是按照Key和Value去使用集合。

2、注意事项

HashMap<Key,value>，Key和Value都可以为空值、Key当重复时会覆盖前面的Key值，Value可重复输入。put输入的数据是无序的。线程存在不安全。

二、HashMap的使用

1、HashMap的创建

HashMap<Object, Object> map = new HashMap<>();

2、常用方法

put()
添加元素
clear()
从此映射中移除所有映射关系。
containsKey(Object key)
如果此映射包含对于指定键的映射关系，则返回 true。
containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
entrySet()
返回此映射所包含的映射关系的 Set 视图。
get(Object key)
返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
remove(Object key)
从此映射中移除指定键的映射关系（如果存在）。
size()
返回此映射中的键-值映射关系数

3、遍历方式

// 第一种遍历，在for循环中使用entries实现Map的遍历
for (Map.Entry<Object, Object> entries : map.entrySet()) {
    Object key = entries.getKey();
    Object value = entries.getValue();
    System.err.println(key.toString() + "\t\t" + value.toString());
}
//第二种遍历，在for循环中遍历key或者values
for (Object key : map.keySet()) {
    System.err.print("key\t" + key.toString() + "\t");
    System.err.print(map.get(key) + "\n");
}
//通过map.values()遍历值集
for (Object value : map.values()) {
    System.err.print(value.toString() + "\t");
}
//第三种遍历，通过Iterator遍历
Iterator<Map.Entry<Object, Object>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<Object, Object> entry = iterator.next();
    Object key = entry.getKey();
    Object value = entry.getValue();
    System.err.println(key.toString() + "\t\t" + value.toString());
}
//第四种遍历通过键查找值遍历
for (Object key : map.keySet()) {
    Object o = map.get(key);
    System.err.println(key.toString() + "\t\t" + o.toString());
}
//lambda表达式
map.forEach((k, v) -> {
    System.err.println(k.toString() + "\t" + v.toString());
});

三、HashMap底层结构

1、数据结构

如图所示，HashMap底层就是一个数组，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。

2、源码

当实例化一个HashMap时，系统会创建一个长度为Capacity的Entry数组，这个长度被称为容量(Capacity)，在这个数组中可以存放元素的位置我们称之为“桶”(bucket)，每个bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。 每个bucket中存储一个元素，即一个Entry对象，但每一个Entry对象可以带一个引用变量，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Entry链。 Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。 Entry是HashMap中的一个静态内部类。

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
        int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
}

四、源码分析

1、成员变量

//默认初始化化容量,即16  
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

//最大容量，即2的30次方  
static final int MAXIMUM_CAPACITY = 1 << 30;  

//默认装载因子  
static final float DEFAULT_LOAD_FACTOR = 0.75f;  

//HashMap内部的存储结构是一个数组，此处数组为空，即没有初始化之前的状态  
static final Entry<?,?>[] EMPTY_TABLE = {};  

//空的存储实体  
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;  

//实际存储的key-value键值对的个数
transient int size;

//阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后，threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold
int threshold;

//负载因子，代表了table的填充度有多少，默认是0.75
final float loadFactor;

//用于快速失败，由于HashMap非线程安全，在对HashMap进行迭代时，如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），需要抛出异常ConcurrentModificationException
transient int modCount;

//默认的threshold值  
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;

2、构造方法

• HashMap():
  HashMap默认无参构造函数，初始容量为16，负载因子为0.75
• HashMap(int initialCapacity):
  initialCapacity就是HashMap的容量大小
• HashMap(int initialCapacity, float loadFactor)
  loadFactor指定负载因子，当size>=capacity*loadfactor的时候，就需要进行扩容操作了。

 //计算Hash值时的key  
    transient int hashSeed = 0;  

    //通过初始容量和状态因子构造HashMap  
    public HashMap(int initialCapacity, float loadFactor) {  
        if (initialCapacity < 0)//参数有效性检查  
            throw new IllegalArgumentException("Illegal initial capacity: " +                                             initialCapacity);  
        if (initialCapacity > MAXIMUM_CAPACITY)//参数有效性检查  
            initialCapacity = MAXIMUM_CAPACITY;  
        if (loadFactor <= 0 || Float.isNaN(loadFactor))//参数有效性检查  
            throw new IllegalArgumentException("Illegal load factor: " +  
                                               loadFactor);  

        this.loadFactor = loadFactor;  
        threshold = initialCapacity;  
        init();//init方法在HashMap中没有实际实现，不过在其子类如 linkedHashMap中就会有对应实现
    }  

    //通过扩容因子构造HashMap,容量去默认值，即16  
    public HashMap(int initialCapacity) {  
        this(initialCapacity, DEFAULT_LOAD_FACTOR);  
    }  

    //装载因子取0.75，容量取16，构造HashMap  
    public HashMap() {  
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);  
    }  

    //通过其他Map来初始化HashMap,容量通过其他Map的size来计算，装载因子取0.75  
    public HashMap(Map<? extends K, ? extends V> m) {  
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);  
        inflateTable(threshold);//初始化HashMap底层的数组结构  
        putAllForCreate(m);//添加m中的元素  
    }  

从上面这段代码我们可以看出，在常规构造器中，并没有马上为数组table分配内存空间（有一个入参为指定Map的构造器例外），事实上是在执行第一次put操作的时候才真正构建table数组。

3、put方法

    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;
        // 如果数组为空，或者数组长度为0，那么进行一次扩容。
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //Hash和数组长度进行 与 运算，如果计算到的位置为空，那么就直接放到该位置上。
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
        //计算到的数组中有元素，这里的e保存的是旧值。
            Node<K,V> e; K k;
            // 第一个元素就是要处理的值，后续会判断是否替换
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 如果是TreeNode，即这个数组中的元素是树。
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
            // 是链表
                for (int binCount = 0; ; ++binCount) {
                    //没找到相同的key，说明要直接在链表尾添加一个节点
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //找到了相同的key，那么直接退出循环
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //如果e!=null的话，那么说明这个HashMap中存在了相同的key
            if (e != null) { 
                V oldValue = e.value;
                //这里就需要到了这个 onlyIfAbsent 参数了，默认false，所以直接将旧节点的值替换了。
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                //因为原本就存在这个key了，那么这时候就直接返回旧值
                return oldValue;
            }
        }
        ++modCount;
        //
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

4、扩容方法

扩容操作通过resize操作实现：

final Node<K,V>[] resize() {
        //oldTab指向原来的数组
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        //原来的容量如果大于0，说明HashMap里已经有值了
        if (oldCap > 0) {
            //旧的容量如果已经大于最大容量，那直接把threshold直接置最大，不扩容直接返回
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //容量和threshold都直接变为原来的两倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //这是带参数的初始化方法，就直接将新容量初始化为threshold。带参数的构造方法会将threshold的值置为初始容量。
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        //如果threshold和原容量都是0，说明要进行初始化
        else { 
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //计算完新的容量之后，更新新的threshold
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        //更新
        threshold = newThr;
        
        //扩容算法中比较核心的部分，就是新建一个数组，并将原来的HashMap中的元素复制到新的数组中去。
        @SuppressWarnings({"rawtypes","unchecked"})
        //新建一个数组，数组初始化长度为上面得到的“newCap”。
        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;
                //找到一个bin不为空，进行后续操作
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //如果这个bin中只有一个元素，那么直接对这个节点进行复制，也就是通过上面介绍的hash方法来计算新的下标。
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                    //如果这个bin后面是树，那么调用TreeNode的split方法进行复制。
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else {
                    //这个bin后面是链表，遍历链表进行复制。
                        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) {
                                // 对应的bin中没有元素，直接将那个元素放到bin中
                                if (loTail == null)
                                    loHead = e;
                                else
                                 // 原本的bin中已经有链表了，那么直接跟在链表尾部
                                    loTail.next = e;
                                loTail = e;
                            }
                            //如果节点在新数组中的位置需要改变，那么就记录在hiHead这个链表中。后续处理
                            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;
    }

5、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;
        // 判断数组不为空的话->数组长度不为0->根据key的hash值算出来的下标的元素不为空，如果都满足则继续找，否则直接返回。
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //找到key所对应的那个bin，先判断第一个值是不是要get的，如果是就返回
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                //如果是TreeNode。调用TreeNode的getTreeNode遍历寻找
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                //遍历链表，寻找要get的值
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

五、常见面试题分析

• HashMap面试题整理：

1、JDK1.7与JDK1.8HashMap有什么区别和联系

• 最重要的一点是底层结构不一样，1.7是数组+链表，1.8则是数组+链表+红黑树结构;

• jdk1.7中当哈希表为空时，会先调用inflateTable()初始化一个数组；而1.8则是直接调用resize()扩容;

• 插入键值对的put方法的区别，1.8中会将节点插入到链表尾部，而1.7中是采用头插；

• jdk1.7中的hash函数对哈希值的计算直接使用key的hashCode值，而1.8中则是采用key的hashCode异或上key的hashCode进行无符号右移16位的结果，避免了只靠低位数据来计算哈希时导致的冲突，计算结果由高低位结合决定，使元素分布更均匀；

• 扩容时1.8会保持原链表的顺序，而1.7会颠倒链表的顺序；而且1.8是在元素插入后检测是否需要扩容，1.7则是在元素插入前；

• jdk1.8是扩容时通过hash&cap==0将链表分散，无需改变hash值，而1.7是通过更新hashSeed来修改hash值达到分散的目的；

• 扩容策略：1.7中是只要不小于阈值就直接扩容2倍；而1.8的扩容策略会更优化，当数组容量未达到64时，以2倍进行扩容，超过64之后若桶中元素个数不小于7就将链表转换为红黑树，但如果红黑树中的元素个数小于6就会还原为链表，当红黑树中元素不小于32的时候才会再次扩容。

2、用过HashMap没？说说HashMap的结构（底层数据结构 + put方法描述）

用过。

• 底层结构：HashMap在JDK1.7是数组+链表，1.8为了解决哈希冲突则是数组+链表+红黑树结构;
• put方法：首先根据key的hashcode重新计算hash值,根绝hash值得到这个元素在数组中的位置(下标),如果该数组在该位置上已经存放了其他元素,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放入链尾.如果数组中该位置没有元素,就直接将该元素放到数组的该位置上。

3、说说HashMap的扩容过程

首先判断原本的capacity是否已经是static final intMAXIMUM_CAPACITY=1<<30;，如果不是，会重新创建新的Entry数组，并将数组长度更改为newCapacity，接着调用了transfer方法，并将新的table和threshold赋值给当前hashMap对象，这里最重要的方法就是transfer，因为这个方法会根据newCapacity重新计算在Entry数组中原先存在的entry的新的散列位置。 计算过程比较简单与重新创建新的hashMap比较类似，就是根据entry的key重新计算出hash值，然后根据新的数组长度计算出应该把老的entry放在新数组的那个位置，如果有冲突就将entry链接其上。

4、HashMap中可以使用自定义类型作为其key和value吗？

可以。需要重写equals()方法和hashCode()方法。

5、HashMap中table.length为什么需要是2的幂次方

这个算法实际就是取模，hash%length，计算机中直接求余效率不如位移运算，源码中做了优化hash&(length-1)，
hash%length==hash&(length-1)的前提是length是2的n次方；

6、HashMap与HashTable的区别和联系

相同点：
都实现了Map接口，保存了Key-Value（键值对）
不同点：
1.HashMap继承AbstractMap类，而HashTable继承Dictionary类。
2.HashMap是线程不安全的，是非Synchronize（同步）的，而HashTable是线程安全的，是Synchronize的。
3.HashTable中key和value都不允许为null，HashMap中空值可以作为Key，也可以有一个/多个Key的值为空值。
4.HashMap的hash数组默认长度大小为16，扩容方式为2的指数，HashTable的hash数组默认长度大小为11，扩容方式为两倍加一。

7、HashMap、LinkedHashMap、TreeMap之间的区别和联系？

相同点：
HashMap,LinkedHashMap,TreeMap都属于Map；Map 主要用于存储键(key)值(value)对，根据键得到值，因此键不允许键重复,但允许值重复。
不同点：
1.HashMap里面存入的键值对在取出的时候是随机的,也是我们最常用的一个Map.它根据键的HashCode值存储数据,根据键可以直接获取它的值，具有很快的访问速度。在Map 中插入、删除和定位元素，HashMap 是最好的选择。
2.TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。
3. LinkedHashMap 是HashMap的一个子类，如果需要输出的顺序和输入的相同,那么用LinkedHashMap可以实现.

8、HashMap与WeakHashMap的区别和联系

1.HashMap和weakHashMap是基于Key-Value的散列表(数组+链表)，采用拉链法实现的。一般用于单线程当中，非线程安全，HashMap中的键是“强键”，weakHashMap中的键是"弱键"。当"弱键"被GC会收时，它对应的键值也会从weakHashMap中删除。
2.继承于抽象类AbstractMap，并且实现Map接口。
3.默认容量大小是16，加载因子是0.75。
4.最多只允许一条key为Null，允许多条value为Null。

9、WeakHashMap中涉及到的强弱软虚四种引用

• 强引用：宁愿内存溢出也不清除强引用的内存
• 软引用SoftReference：丢到SoftReference中就是软引用，内存快溢出了就把软引用的干掉
• 弱引用WeakReference：一旦执行GC就会清除
• 虚引用：相当于没有引用，在任何时候都有可能被垃圾回收器回收（基本不用）

10、HashMap是线程安全的吗？引入HashTable和ConcurrentHashMap

HashMap是非线程安全的。

• Hashtable 在 JDK1.0 的时候就存在了，并在 JDK1.2 版本中实现了 Map 接口，而 ConcurrentHashMap 则是在 JDK1.5 中才出现的，也正是因为它们出现的年代不同，而后出现的往往是对前面出现的类的优化，所以它们在实现方式以及性能上，也存在着较大的不同。

• Hashtable 实现并发安全的原理是通过 synchronized 关键字，ConcurrentHashMap 实现线程安全的原理是利用了 CAS + synchronized + Node 节点的方式。

• 当线程数量增加的时候，Hashtable 的性能会急剧下降，因为每一次修改都需要锁住整个对象，而其他线程在此期间是不能操作的。不仅如此，还会带来额外的上下文切换等开销，所以此时它的吞吐量甚至还不如单线程的情况。
  而在 ConcurrentHashMap 中，就算上锁也仅仅会对一部分上锁而不是全部都上锁，所以多线程中的吞吐量通常都会大于单线程的情况，也就是说，在并发效率上，ConcurrentHashMap 比 Hashtable 提高了很多。

• Hashtable（包括 HashMap）不允许在迭代期间修改内容，否则会抛出ConcurrentModificationException 异常，相反，ConcurrentHashMap 即便在迭代期间修改内容，也不会抛出ConcurrentModificationException。