深入理解HashMap

引言

HashMap 根据键的 hashCode 值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。 HashMap 最多只允许一条记录的键为 null ，允许多条记录的值为 null 。HashMap 非线程安全，即任一时刻可以有多个线程同时写 HashMap，可能会导致数据的不一致。如果需要满足线程安全，可以用 Collections的synchronizedMap 方法使 HashMap 具有线程安全的能力，或者使用ConcurrentHashMap。

HashMap基本原理

HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。
HashMap是数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，

HashMap的扩容机制

什么时候扩容：当向容器添加元素的时候，会判断当前容器的元素个数，如果大于等于阈值—即当前数组的长度乘以加载因子的值的时候，就要自动扩容啦。(这里就是懒加载)

jdk1.7 一般我们在扩容的时候，一般是把长度扩为原来2倍，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。

扩容(resize)就是重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。

void resize(int newCapacity) {   //传入新的容量  
    Entry[] oldTable = table;    //引用扩容前的Entry数组  
    int oldCapacity = oldTable.length;  
    if (oldCapacity == MAXIMUM_CAPACITY) {  //扩容前的数组大小如果已经达到最大(2^30)了  
        threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了  
        return;  
    }  
    Entry[] newTable = new Entry[newCapacity];  //初始化一个新的Entry数组  
    transfer(newTable);                         //！！将数据转移到新的Entry数组里  
    table = newTable;                           //HashMap的table属性引用新的Entry数组  
    threshold = (int) (newCapacity * loadFactor);//修改阈值  
}  

我们分析下resize的源码，鉴于JDK1.8融入了红黑树，较复杂，为了便于理解我们仍然使用JDK1.7的代码，好理解一些，本质上区别不大，具体区别后文再说。

这里就是使用一个容量更大的数组来代替已有的容量小的数组，transfer()方法将原有Entry数组的元素拷贝到新的Entry数组里。

void transfer(Entry[] newTable) {  
    Entry[] src = table;                   //src引用了旧的Entry数组  
    int newCapacity = newTable.length;  
    for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组  
        Entry<K, V> e = src[j];             //取得旧Entry数组的每个元素  
        if (e != null) {  
            src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）  
            do {  
                Entry<K, V> next = e.next;  
                int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置  
                e.next = newTable[i]; //标记[1]  
                newTable[i] = e;      //将元素放在数组上  
                e = next;             //访问下一个Entry链上的元素  
            } while (e != null);  
        }  
    }  
}  

static int indexFor(int h, int length) {  
    return h & (length - 1);  //与运算，寻找key所在数组下标
}  

newTable[i]的引用赋给了e.next，也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链表的头部位置；这样先放在一个索引上的元素终会被放到Entry链的尾部(如果发生了hash冲突的话），这一点和Jdk1.8有区别，下文详解。在旧数组中同一条Entry链上的元素，通过重新计算索引位置后，有可能被放到了新数组的不同位置上。

HashMap出现循环链表

这个问题专门指jdk1.7里面hashmap线程不安全，因为会出现循环链表，在多个线程同时进行扩容得时候由于指针会不停变换，
这里拿两个线程来指，并且是在不执行rehash得情况下
第一个线程会新建个2倍空间得数组然后根据头指针得不断插入然后指针链表会倒置，然后这时候haspMap开始第二个线程得扩容，他的next会指向空，而e指向e.next得时候就出现循环

//resize方法片段
do {  
                Entry<K, V> next = e.next;  
                int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置  
                e.next = newTable[i]; //标记[1]  
                newTable[i] = e;      //将元素放在数组上  
                e = next;             //访问下一个Entry链上的元素  
            } while (e != null);  
     

哈希碰撞

index数组下标根据hashcode进行位运算和hash算法然后的出来的
table数组长度有限，当加入的数据过多时总会出现有些key值生成的hash值相同的情况，也就是说不同key值可能会对应同样的index，这种情况就叫做哈希冲突

解决方法：
jdk1.7 将所有关键字为同义词的记录存储在同一线性链表中
jdk1.8HashMap使用链表和红黑树避免哈希冲突（相同hash值），当链表长度大于TREEIFY_THRESHOLD（默认为8）时，将链表转换为红黑树，当然小于UNTREEIFY_THRESHOLD（默认为6）时，又会转回链表以达到性能均衡。

HashMap,jdk1.7与1.8的区别

（1）、JDK7：创建hashMap对象时，则初始化table容量为16
JDK8：创建hashMap对象时，没有初始化table，仅仅只是初始化负载因子。当只有第一次添加时才会初始化table容量为16
（2）、JDK7：table的类型为Entry
JDK8：table的类型为Node
（3）、JDK7：哈希表为数组+链表，不管链表的总结的数是多少，都不会变成树结构
JDK8：哈希表为数组+链表+红黑树，(节点数>=8） &&桶的总个数（table的容量）>= 64) 时，会将链表结构变成红黑树
详细区别

HashMap和HashTable区别

HashMap和HashTable都是针对Map接口的实现，所以它们的功能是差不多的，它们的主要区别在线程安全这一块，先说结论：HashMap线程不全，而HashTable则是线程安全的

1. put的时候导致的多线程数据不一致

比如有两个线程A和B，首先A希望插入一个key-value对到HashMap中，首先计算记录所要落到的 hash桶的索引坐标，然后获取到该桶里面的链表头结点，此时线程A的时间片用完了，而此时线程B被调度得以执行，和线程A一样执行，只不过线程B成功将记录插到了桶里面，假设线程A插入的记录计算出来的 hash桶索引和线程B要插入的记录计算出来的 hash桶索引是一样的，那么当线程B成功插入之后，线程A再次被调度运行时，它依然持有过期的链表头但是它对此一无所知，以至于它认为它应该这样做，如此一来就覆盖了线程B插入的记录，这样线程B插入的记录就凭空消失了，造成了数据不一致的行为。

2. HashMap的初始容量为16，Hashtable初始容量为11，两者的填充因子默认都是0.75
3. HashMap扩容时是当前容量翻倍即:capacity2，Hashtable扩容时是容量翻倍+1即:capacity2+1。
4. HashMap可以使用null作为key，不过建议还是尽量避免这样使用。HashMap以null作为key时，总是存储在table数组的第一个节点上。而Hashtable则不允许null作为key。
5. HashMap继承了AbstractMap，HashTable继承Dictionary抽象类，两者均实现Map接口。
6. HashMap的resize可能会引起死循环（仅针对JDK 1.7),而hashTable不会因为他每个方法有synchronized
   外需要说明的是，由于HashTable为了实现线程安全使用了synchronized关键字，它的执行速度会比HashMap慢，所以在不存在并发的时候优先考虑使用HashMap，而存在并发的情况下为了保证线程安全，建议使用HashTable

ConcurrentHashMap核心原理

锁分段技术 Hashtable容器在竞争激烈的并发环境下表现出效率低下的原因是所有访问Hashtable的线
程都必须竞争同一把锁。假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访
问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是
ConcurrentHashMap所使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一
把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

HashMap和ConcurrentHashMap

1. ConcurrentHashMap 不允许空键值对,HashMap允许一个key为null多个value为null
2. 前者线程不安全后者线程安全，引入 ConcurrentHashMap 是为了在同步集合HashTable之间有更好的选择； HashTable 与 HashMap 、ConcurrentHashMap 主要的区别在于HashMap不是同步的、线程不安全的和不适合应用于多线程并发环境下，而 ConcurrentHashMap 是线程安全的集合容器