HashMap原理分析

HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。
此外，在java编程语言中，最基本的结构就是两种：数组、模拟指针（引用）。所有的数据结构都可以用这两个基本结构来构造。
HashMap底层就是一个数组结构，数组中的每一项又是一个链表。新来的Entry节点插入链表时，使用的是“头插法”。使用“头插法”的原因是hashmap的作者认为“后插入的Entry被查找的可能性更大”。
当新建一个HashMap的时候，就会初始化一个数组。

1、当new一个HashMap时，源码如下：

/** 
 * The table, resized as necessary. Length MUST Always be a power of two. 
 */  
transient Entry[] table;  

static class Entry<K,V> implements Map.Entry<K,V> {  
    final K key;  
    V value;  
    Entry<K,V> next;  
    final int hash;  
    ……  
} 

分析：Entry就是数组中的元素，Map.Entry其实是一个key.value（键值对），这个键值对有指向下一个元素的引用，所以这就又构成了一个链表结构。

2、存储（put）数据时，源码如下：

public V put(K key, V value) {  
    // HashMap允许存放null键和null值。  
    // 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。  
    if (key == null)  
        return putForNullKey(value);  
    // 根据key的keyCode重新计算hash值。  
    int hash = hash(key.hashCode());  
    // 搜索指定hash值在对应table中的索引。  
    int i = indexFor(hash, table.length);  
    // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。  
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
        Object k;  
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
            V oldValue = e.value;  
            e.value = value;  
            e.recordAccess(this);  
            return oldValue;  
        }  
    }  
    // 如果i索引处的Entry为null，表明此处还没有Entry。  
    modCount++;  
    // 将key、value添加到i索引处。  
    addEntry(hash, key, value, i);  
    return null;  
}  

分析：在put元素时，先根据key的hashCode重新计算出hash值，然后再根据hash值找出这个元素在数组中的位置，如果数组的此处已经存放了数据，那么这个元素会议链表的形式保存，新的在链头，旧的在链尾；如果数组的此处没有存放数据，则直接将该元素保存在数组的此位置上。

2-1 put方法中的addEntry方法，根据计算出的hash值，将key-value对放在数组table的i索引处。
源码如下：

void addEntry(int hash, K key, V value, int bucketIndex) {  
    // 获取指定 bucketIndex 索引处的 Entry   
    Entry<K,V> e = table[bucketIndex];  
    // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry  
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
    // 如果 Map 中的 key-value 对的数量超过了极限  
    if (size++ >= threshold)  
    // 把 table 对象的长度扩充到原来的2倍。  
        resize(2 * table.length);  
}  

分析：当存储HashMap中的key-value键值对时，是没有考虑Entry中的value的，只根据key来计算并决定每个Entry的存储位置。换言之， Map 集合中的 value 是 key 的附属品。决定了 key 的存储位置之后，value 随之保存在那里即可。

2-2 hash(int h)方法：
根据key的hashCode重新计算一次散列。源码如下：

static int hash(int h) {  
    h ^= (h >>> 20) ^ (h >>> 12);  
    return h ^ (h >>> 7) ^ (h >>> 4);  
}  

分析：此算法加入了高位计算，防止低位不变高位变化时，造成hash冲突。
HashMap中寻找某个元素，需要根据key的hash值来求得对应数组中的位置。如何计算这个位置就是hash算法。HashMap的数据结构是数组和链表的结合，所以HashMap里面元素位置分布的越均匀越好，尽量使每个位置上的元素数只有一个，那么当用hash算法求得这个位置的时候，马上就可以计算出对应位置的元素，不用去遍历链表，这样就大大优化了查询的效率。
对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(int h) 方法所计算得到的 hash 值也相同。按理来说，首先想到的是hash值对数组长度进行取模运算，这样一来，元素的分布相对来说是均匀的，但取模运算的消耗较大。
2-3 在HashMap中，调用 indexFor(int h, int length) 方法计算该对象应该保存在数组的哪个索引处。
indexFor(int h, int length) 源代码如下：

static int indexFor(int h, int length) {  
    return h & (length-1);  
}  

在解释indexFor的源代码之前，需要先了解hashmap容量的底层实现。hashmap的长度一直是2的n次幂，这是hashmap的作者对hashmap在速度上的优化。hashmap的构造器有如下代码：

int capacity = 1;
    while (capacity < initialCapacity)  
        capacity <<= 1;

构造器中的这段代码保证了对hashmap初始化时，容量总是2的n次幂。
回过头来看indexFor的实现，h& (length-1)既是h%length，等同于对length取模，&比%的运算效率更高，所以作者采用的是&（位运算）。
至于为什么容量设计成2的n次幂的好处：使hashmap中的数据尽量均匀分布。以后会单独分析为什么这样会分布均匀。

3、读取（get）方法源码如下：

public V get(Object key) {
    if (key == null)
        return getForNullKey();
        //根据key的hashcode找到在数组中的对应位置
    int hash = hash(key.hashCode());
    //使用key的equals方法在对应位置的链表中找到需要的元素
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
        e != null;
        e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))  
            return e.value;
    }
    return null;
}

分析：从HashMap中get元素时，先计算key的hashCode，然后找到在数组中对应位置的元素，再通过key的equals方法在此位置的链表中找到需要的元素。

总结：

hashmap的底层是将key-value当作整体来处理的。Entry[]就是一个数组，一个Entry保存一个key-value对儿。
put一个Entry时，先根据hash算法确定应保存在数组的什么位置，再根据equals方法确定在该数组位置上的链表中的存储位置；
get一个Entry时，也是先根据hash算法找到在数组中的存储位置，再使用equals方法从此位置的链表中取出此Entry。

补充：当链表过长时，Java8引入红黑树来解决效率问题。