Java HashMap 实现原理

Java HashMap 实现原理

首先唠叨一句看Java源码虽然累，但是还能看懂。看Python源码是真看不懂啊。那是太糟心了。
HashMap是Java实现Hash算法的存储结构。学习HashMap之前要先了解Hash算法。知道原理查看源码就会明白Java为什么采用数组+链表的方式实现HashMap来解决Hash冲突。
Java是采用   **链地址法**   实现的Hash算法。那什么是链地址法？

1.简介
2.链地址法
3.HashMap源码分析
4.总结

2.链地址法

2.1链地址法定义

假设散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点，均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链法中，装填因子α可以大于 1，但一般均取α≤1。

2.2 Java的链地址法实现方式

Java的链地址法是通过数组+单向链表实现的。默认数组的长度为16则数组的下边为[0…15]。当向HashMap中put值时候，会用15与key的Hash值做 & 位运算。算出 [0…15]中的某一个下标，如第一个put的值直接放入arr[7]中。为什么会这样存储那？因为根据数组下标的查询速度是最快的这个大家都应该知道。

而当再次put时下标同样为7怎么办那？这就是Hash冲突。Java中会将存入的put进来的值封装一个单向链表的节点。数组中存储节点元素。当hash冲突时。就会在已有节点向下添加hash值相同但是key不同的新的节点。如果hash值相同key值也相同时就会覆盖。

看图就明白了

3.HashMap源码分析

3.1 HashMap 的几个重要属性

//HashMap存储的东西就是这个Node 是一个单向链表
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
   }     
//内部实现存储的数组
transient Node<K,V>[] table;
//size表示HashMap中存放KV的数量（为链表和树中的KV的总和）。
transient int size;
//threshold表示当HashMap的size大于threshold时会执行resize操作。 
//threshold=capacity*loadFactor
int threshold;
//装载因子。装载因子用来衡量HashMap满的程度。loadFactor的默认值为0.75f
//装载因子作用是为了避免出现hash冲突的情况。
final float loadFactor;

3.2 构造方法HashMap(int initialCapacity, float loadFactor)

    public HashMap(int initialCapacity, float loadFactor) {
        ...
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

initialCapacity:初始化容量 默认 16
loadFactor:装载因子 默认 0.75f
首先 初始化HashMap 传入initialCapacity 需要经过 tableSizeFor(initialCapacity)处理返回数组的长度。
tableSizeFor()方法的作用是找到大于initialCapacity的最近的2 的n次幂数作为 table数组的长度。
从构造方法可以看出：new HashMap() 时 HashMap 的 threshold 最大容量为2的N次幂。但在这里threshold 只是做一个存储initialCapacity值的操作。
因为当第一次调用putVal时table数组为null 需要调用resize(）重新构造数组table

3.3 resize() 方法

直接上代码

 final HashMap.Node<K,V>[] resize() {
        HashMap.Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        //1 当table数组再次扩容时
        if (oldCap > 0) {
            //如果table数组的最大长度大于等于最大容量时 不进行扩容 返回当前table
            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
        }
        //2.1 传入参数情况下：当table首次扩容时 数组大小= threshold 上面说的threshold中间值作用在这里体现
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        //3 不传入参数情况下：当table首次扩容时 因为table现在为null 
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //2.2 只有在传入参数情况下：newThr到这里才 newThr=0 所以 threshold到这里进行改变值 newCap * loadFactor 操作
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                    (int)ft : Integer.MAX_VALUE);
        }
        // 更新 threshold hashMap最大容量
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
        table = newTab;
        ...
        return newTab;
    }

3.4 putVal()方法

直接上代码

    /**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //当第一次put值的时候 先初始化table 返回n  数组的长度
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // (n - 1) & hash 数组的最大下标与key的hash值做 且位运算 算出 存储值的下标 当p 为null时 说明此下标没有值 直接赋值   
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
       //    当p ！=null时
        else {
            Node<K,V> e; K k;
            //如果 hash值相同 且 key的值也相同时 说明这是替换操作 
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //如果   节点类型为红黑树 则向红黑树 put值
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //否则向存在的节点 向下添加子节点 这里就是Hash冲突的情况
            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;
                }
            }

            ...
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

4.总结

Java8中对HashMap做了TreeNode优化。通过红黑树存储Hash冲突的值。提高冲突情况下的查询效率。
本文只分析单项链表的方式，原理都是一样的。大家可以看看HashMap源码进行了解。

不足之处请多多指教，谢谢！