一文讲透HashMap结构以及put原理，面试官来吧

本文主要基于JDK1.8来讲解。

java类库中包含了Map的集中基本实现，包括：HashMap、TreeMap、LinkedHashMap、WeakHashMap、ConcurrentHashMap、IdentityHashMap。今天我们主要讲一下面试中经常问到的HashMap。

哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，重要性可见一斑。本文会对java集合框架中的对应实现HashMap的实现原理进行讲解，然后会对JDK8的HashMap源码进行分析。

一、HashMap数据结构

HashMap是由数组+链表+红黑树（1.8）组成的。

　　数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)，当然，对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)；对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n)

　　线性链表：对于链表的新增，删除等操作（在找到指定操作位置后），仅需处理结点间的引用即可，时间复杂度为O(1)，而查找操作需要遍历链表逐一进行比对，复杂度为O(n)

　　二叉树：对一棵相对平衡的有序二叉树，对其进行插入，查找，删除等操作，平均复杂度均为O(logn)。

　　哈希表：相比上述几种数据结构，在哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O(1)，接下来我们就来看看哈希表是如何实现达到惊艳的常数阶O(1)的。

        哈希冲突

　　然而万事无完美，如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？哈希冲突的解决方案有多种:开放定址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，而HashMap即是采用了链地址法，也就是数组+链表+红黑树的方式。

二、HashMap 结构、重要属性、构造函数

　HashMap的主干是一个Node数组。Node是HashMap的基本组成单元，每一个Node包含一个key-value键值对。

/** HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，
  * 主干数组的长度一定是2的次幂，至于为什么这么做，后面会有详细分析。
**/
transient Node[] table;

 Node(1.7叫Entry) 是HashMap中的一个静态内部类。代码如下:

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


        Node(int hash, K key, V value, Node next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
    // 省略部分代码
      ....
    }

HashMap中重要属性

//实际存储的key-value键值对的个数
transient int size;
//扩容阈值，默认16，最大1<<30 下一个要调整的大小值 capacity * loadFactor
int threshold;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final int MAXIMUM_CAPACITY = 1 << 30;


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


/**
* 用于快速失败，由于HashMap非线程安全，在对HashMap进行迭代时，
* 如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），
* 需要抛出异常ConcurrentModificationException
* if (modCount != expectedModCount)
    throw new ConcurrentModificationException();
**/
transient int modCount;
// 链表下节点数量大于此值 转变为红黑树
static final int TREEIFY_THRESHOLD = 8;
// 红黑树节点数量变为小于此值时 转变为链表
static final int UNTREEIFY_THRESHOLD = 6;

HashMap有4个构造器，其他构造器如果用户没有传入initialCapacity 和loadFactor这两个参数。

initialCapacity默认为16

loadFactory默认为0.75

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;
        this.threshold = tableSizeFor(initialCapacity);
}
 public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
}


 public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
 }


public HashMap(Map m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

从上面这段代码我们可以看出，前三个构造函数没有为数组table分配内存空间，而是在执行put操作的时候才真正构建table数组，最后一个指定入参Map的对数组table分配了空间，也就是putMapEntries(m, false);这个方法。

看了HashMap的Node结构以及主要属性和构造函数，咱们画一下HashMap的结构

三、HashMap put原理：

  

 put流程图

看一下代码

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node[] tab; Node p; int n, i;
       // 判断是否为null 长度等于0
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 计算hash 判断是否再存key
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node e; K k;
            // 存在key覆盖
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 判断是否黑红树treeNode
            else if (p instanceof TreeNode)
                // 黑红树插入
                e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        // 尾插法，提一句1.7用的头插法，1.7还有死循环问题
                        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;
            }
        }
    /**
        * 用于快速失败，由于HashMap非线程安全，在对HashMap进行迭代时，
        * 如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），
        * 需要抛出异常ConcurrentModificationException
        **/
        ++modCount;
    // 判断是否需要扩容
        if (++size > threshold)
            // 扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }

本文先讲到hashMap put原理，后面将会再讲一下扩容原理，以及线程安全的ConcurrentHashMap原理。

如果对你有用的话，关注小编转发，大家一起学习进步。

后续还会有Spring 、mybatis 等文章更新。