老生常谈系列一-----------HashMap底层原理(源码分析)

本文主要介绍HashMap的底层原理

在前几年的面试里，最经常被问到的就是这些数据结构，ArrayList，LinkedList，HashMap…等数据结构，但现在问的就比较少了，只有HashMap会问到，只是问的次数没以前那么多，特别是会问Hashtable和ConcurrenHashMap的区别，但这里只介绍HashMap的一个底层原理。

1.HashMap是什么？

我们都知道ArrayList底层是由数组实现的，有序数组存储数据，它查找数据的效率较高高，但是插入和删除效率较低
而LinkedList底层是由双向链表进行存储数据的，它查找数据要一次一次的比较来查找出需要的数据，所以索引效率低，但是插入和删除效率高
两者取长补短就产生了哈希散列这种存储方式，就是数组+链表，也就是HashMap的存储数据结构。

2.HashMap底层原理

HashMap属性介绍：

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//hashmap默认长度，如果不指定长度就会使用
    static final int MAXIMUM_CAPACITY = 1 << 30;//hashmap最大长度
    static final float DEFAULT_LOAD_FACTOR = 0.75f;//负载因子的默认值
    static final int TREEIFY_THRESHOLD = 8;//链表的长度达到该值，就会判断是否转换红黑树
    static final int MIN_TREEIFY_CAPACITY = 64;//当数组长度达到该值，就会将达到阀值的链表转为红黑树，阀值就是TREEIFY_THRESHOLD属性
    //节点类就是链表存放KV和下一个节点指引，还有hash值
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
        ........
    }
    //该方法计算用来hash值，下面会介绍
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

2.1 HashMap的构造方法：

先看一下代码：

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

从代码中可以看到，不带参数的话，使用的都是默认参数，这里最关键的是带两个参数的构造方法，一个初始容量，一个负载因子。
这里面它有三个判断，判断初始容量不能小于0和负载因子不能小于0，否则都会抛出异常。还有一个是初始容量大于最大容量，则重新设置容量为最大容量。
最后两行代码，第一行是对负载因子进行赋值，第二行是调用的了一个方法,是对阈值进行赋值，这个方法是根据初始容量来计算阈值的，叫tableSizeFor()，它里面首先有个int变量n，将初始容量-1并赋值给n，然后进行一系列的按位或运算加无符号右移运算，其实就是如果用户指定的初始容量不是2的幂次方。通过这一系列的运算，最后得到一定是大于输入参数且最近的2的整数次幂的数，比如：10，最后会返回16，不过这里计算的阈值不是最终的阈值，最终其实计算的是数组的长度，会在resize( )方法里面进行赋值。下面的put方法会提到。
tableSizeFor()源码：

static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;//最后会返回n+1
    }

原理： 取决于该数的二进制最高位，比如：初始容量为10，那么10-1=9的二进制为1001，那经过这个方法之后，返回的就是二进制为1111的15再+1，就等于16，如果是22则22-1=21的二进制为10101，最后会返回 11111+1，就等于100000,十进制为32的数。而如果是16的话，16-1等于15的二进制为1111，最后还是会返回1111+1的数，也就是10000，十进制是16的数。
举例：
一、
cap=13 //假设初始容量定义为13
n=13-1=12
12的二进制=1100
n |= n >>> 1; // n=1100 | 0110=1110
n |= n >>> 2; // n=1110 | 0011=1111
n |= n >>> 4; // n=1111 | 0000=1111
n |= n >>> 8; // n=1111 | 0000=1111
n |= n >>> 16; // n=1111| 0000=1111
n+1=10000 //该数肯定是2的整数幂
二进制10000=16

二、
cap=3079257850 //假设初始容量定义为3079257850
n=3079257850-1=3079257849
转为二进制=1011-0111-1000-1001-1011-1110-1111-1001 //32位
n |= n >>> 1;
n= 1011-0111-1000-1001-1011-1110-1111-1001 |
     0101-1011-1100-0100-1101-1111-0111-1100 =
     1111-1111-1100-1101-1111-1111-1111-1101

n |= n >>> 2;
n= 1111-1111-1100-1101-1111-1111-1111-1101 |
     0011-1111-1111-0011-0111-1111-1111-1111 =
     1111-1111-1111-1111-1111-1111-1111-1111

n |= n >>> 4;
n= 1111-1111-1111-1111-1111-1111-1111-1111 |
     0000-1111-1111-1111-1111-1111-1111-1111 =
     1111-1111-1111-1111-1111-1111-1111-1111

n |= n >>> 8;//以此类推，得到的肯定是32个1
n |= n >>> 16;//以此类推，得到的肯定是32个1

n+1=1-0000-0000-0000-0000-0000-0000-0000-0000 //该数肯定是2的整数幂

因此取决于该数的二进制最高位。 这就是tableSizeFor()的奥妙之处。

2.2 put()方法：

初始化完后，讲一下put()方法，也就是如何添加的，首先得有一个Node数组，还有一个Node节点p，节点中存放有next，hash，key，value属性，next代表下一个Node节点，hash代表经过hash()方法计算过的值；
源码：

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) {
		//n代表数组长度，i代表数组下标，p代表冲突的节点
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //第一次添加元素就走这个if逻辑，因为第一次添加元素数组是空的。
        if ((tab = table) == null || (n = tab.length) == 0)
         	//通过resize()方法为数组进行初始化，这一步就是上面所说的将阀值赋值给数组长度.
            n = (tab = resize()).length;
        //这个if就是先通过hash算法，找到对应的数组下标。
        //判断该下标是否有节点，没节点就走该逻辑
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
        //有节点说明hash冲突，就走该逻辑
            Node<K,V> e; K k;
            //首先判断两个key的hash值是否相等，相等再通过equals方法判断该节点的key与要添加的key是否相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //如果判断都为true，则将冲突节点赋值给e
                e = p;
            //key不相等，就判断冲突节点是否为红黑树
            else if (p instanceof TreeNode)
            	//如果是红黑树，就交给红黑树来添加节点。
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //如果key既不相等，也不是红黑树类型，就只能是链表类型了。
            else {
            	//遍历链表查询是否有相等的key存在。
                for (int binCount = 0; ; ++binCount) {
                	//如果遍历完不存在，则直创建新的节点，添加在尾部。
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //判断是否需要进行链表改造红黑树。
                        //首先判断链表长度是否大于等于8，
                        if (binCount >= TREEIFY_THRESHOLD - 1) // 这里是从0开始遍历的，所以-1
                        	//链表长度大于等于8，就走该方法
                        	//该方法其实就是先判断数组的长度是否到达64或以上，如果不是的话就只进行resize()扩容操作。
                        	//如果是的话就将该链表转为红黑树
                            treeifyBin(tab, hash);
                        break;
                    }
                    //这里就是判断key是否相等
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                  	//这里是遍历链表使用的。遍历一次e赋值给p一次
                    p = e;
                }
            }
            //判断e，如果不等于空，说明没有添加新的节点，只是更新了节点。就是将key对应的value更新，将旧的value返回。
            if (e != null) {
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //如果是空的，则没有添加新的节点.就走该逻辑
        //首先对维护者迭代器的变量+1，
        //然后判断容量是否达到阈值，达到了就进行扩容操作。
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

2.3 hash()方法：

其实就是先获取该key的hashCode值，再把hashCode进行无符号右移16位，然后将没有右移的hashCode和已经进行右移的hashCode进行异或运算。
源码：

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

hash值的作用主要就是在添加元素的时候，要根据这个hash值来进行hash运算来取得数组的下标，就是元素应该存放的位置。
举例：
“apple”字符串
hashCode=93029210
转成二进制=101-1000-1011-1000-0011-0101-1010
无符号右移16位=101-1000-1011
异或运算：
101100010111000001101011010
               10110001011
————————————————
               11011010001

结果为：11011010001

异或运算：参加运算的两个对象，如果两个相应位相同为0，相异为1。

2.4 resize( )方法

什么时候调用该方法？
1.第一次添加元素，需要初始化数组的时候。(上面提到过)
2.容器中的元素数量 > 负载因子 * 容量，如果负载因子是0.75，容量是16，那么当容器中数量达到13 的时候就会扩容。对数组中的每一个元素进行重新分配位置，扩容大小为两倍。
3.如果某个链表长度达到了8，并且容量小于64，则也会用进行扩容来代替红黑树。

源码：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//table就是节点数组
        //当第一次添加元素时，数组为空，所以oldCap=0，
        //第二次添加元素时，数组已经初始化完，oldCao=数组长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //这个threshold的赋值在带两个参数的构造方法中。
        int oldThr = threshold;
        //代表新的数组长度和新的扩容阈值
        int newCap, newThr = 0;
        //判断数组长度是否大于0；只有数组被初始化完成才会走该逻辑。
        if (oldCap > 0) {
        	//这里是判断数组长度是否达到最大值
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //这里是对数组长度进行扩容操作
            //如果(当前数组长度 *2 < MAXIMUM_CAPACITY && 当前数组长度 >= 默认长度16)
            //操作：新阈值 = 旧阈值 * 2
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //判断阈值是否大于0，只有使用带参的构造方法，阈值才会被赋值，才会走该逻辑。
        //只有第一次添加元素时才可能走该逻辑。(初始化数组)
        else if (oldThr > 0) // initial capacity was placed in threshold
        	//把阈值赋值给新的数组长度(这里就是在介绍构造方法提到的，将扩容阈值赋值给数组长度)
        	//就是自定义初始容量，不是2的整数幂，经过tableSizeFor方法，就会变成2的整数幂
            newCap = oldThr;
        //使用了无参构造方法，并且第一次添加元素就进入该逻辑(初始化数组)
        //根据构造方法得知，未定义初始容量，扩容阈值就不会被赋值。因此oldThr=0
        //因为第一次添加，oldCap=0，
        else {               // zero initial threshold signifies using defaults
        	//新的数组长度使用默认长度=16
        	//新的扩容阈值=负载因子*数组默认长度=0.75*16
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //判断新的阈值为0。有两种情况才会进入该逻辑
        // 第一种：进入此“if (oldCap > 0)”中且不满足该if中的两个if 
        // 第二种：进入这个“else if (oldThr > 0)”
        //分析：进入此if证明用的是带参构造，如果是第一种情况就说明是进行扩容且oldCap（旧容量）小于16。
        //如果是第二种说明是第一次put操作
        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;
    }

2.5 get( )方法

1.通过key的hashCode和寻址算法得到数组下标，判断该位置上的第一个node是否满足条件,如果满足条件,直接返回

2.如果不满足条件,判断当前node是否是最后一个,如果是,说明不存在key,则返回null

1. 如果不是最后一个,判断是否是红黑树,如果是红黑树,则使用红黑树的方式获取对应的key。
2. 如果不是红黑树,则遍历链表是否有满足条件的,如果有,直接返回,否则返回null

源码：

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

总结：
put方法流程：
首先得有一个Node数组，还有一个Node节点p，节点中存放有next，hash，key，value属性，next代表下一个Node节点，hash代表经过hash()方法计算过的值,；
1.判断数组是否为空，因为是第一次添加数据，所以肯定是空的，那么就调用resize( )方法初始化，长度为 2的整数幂的节点数组，如果没指定初始容量那就使用默认长度。

2.通过与运算计算对应 hash 值的下标，如果对应下标的位置没有元素，则直接创建一个。

3.如果有元素，则说明 hash 冲突了，则再次进行 3 种判断。
这里定义了一个空节点e。
  3.1判断两个冲突的key是否相等，equals 方法的价值在这里体现了。如果相等，则将已经存在的节点赋给节点e。最后更新e的value，也就是替换操作。
  3.2如果key不相等，则判断是否是红黑树类型，如果是红黑树，则交给红黑树追加此元素。
  3.3如果key既不相等，也不是红黑树，则是链表，那么就遍历链表中的每一个key和给定的key判断是否相等。如果有相等的直接赋值给节点e，然后退出遍历。如果没有相等的，则创建新的节点，添加在尾部。再判断链表的长度是否大于等于8，看看是否需要改变节点的存储结构，调用treeifyBin()方法。
  treeifyBin()：
  判断当前数组的长度：
    如果不足64，就只进行resize( ),扩容节点数组，
    如果达到64，那么就将 链表改造为红黑树

4.最后，如果这三个判断返回的节点 e 不为null，则说明key重复，则更新key对应的value的值，直接返回已存在的value值，也就是旧的value值。

5.如果节点e为null，则对维护着迭代器的modCount 变量加一。
  5.1最后判断，如果当前数组的长度已经大于阀值了,则进行扩容。最后返回空。