HashMap和ConcurrentHashMap的区别，HashMap的底层源码。

　　Hashmap本质是数组加链表。根据key取得hash值，而后计算出数组下标，若是多个key对应到同一个下标，就用链表串起来，新插入的在前面。

　　ConcurrentHashMap：在hashMap的基础上，ConcurrentHashMap将数据分为多个segment，默认16个（concurrency level），而后每次操做对一个segment加锁，避免多线程锁的概率，提升并发效率。

 

1、HashMap概述

 

　　HashMap基于哈希表的 Map 接口的实现。此实现提供全部可选的映射操做，并容许使用 null 值和 null 键。（除了不一样步和容许使用 null 以外，HashMap 类与 Hashtable 大体相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

 

　　值得注意的是HashMap不是线程安全的，若是想要线程安全的HashMap，能够经过Collections类的静态方法synchronizedMap得到线程安全的HashMap。

1  Map map = Collections.synchronizedMap(new HashMap());

 

2、HashMap的数据结构

　HashMap的底层主要是基于数组和链表来实现的，它之因此有至关快的查询速度主要是由于它是经过计算散列码来决定存储的位置，可以很快的计算出对象所存储的位置。HashMap中主要是经过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就同样。若是存储的对象对多了，就有可能不一样的对象所算出来的hash值是相同的，这就出现了所谓的hash冲突。学过数据结构的同窗都知道，解决hash冲突的方法有不少，HashMap底层是经过链表来解决hash冲突的。

                                      

从上图中能够看出，HashMap底层就是一个数组结构，数组中存放的是一个Entry对象，若是产生的hash冲突，也就是说要存储的那个位置上面已经存储了对象了，这时候该位置存储的就是一个链表了。咱们看看HashMap中Entry类的代码：

 1 static class Entry<K,V> implements Map.Entry<K,V> {
 2         final K key;
 3         V value;
 4         Entry<K,V> next;
 5         final int hash;
 6 
 7         /**
 8          * Creates new entry.
 9          */
10         Entry(int h, K k, V v, Entry<K,V> n) {
11             value = v;
12             next = n; //hash值冲突后存放在链表的下一个
13             key = k;
14             hash = h;
15         }
16 
17         .........
18     }

HashMap其实就是一个Entry数组，Entry对象中包含了键和值，其中next也是一个Entry对象，它就是用来处理hash冲突的，造成一个链表。

3、HashMap源码分析

　　先看看HashMap类中的一些关键属性：

1 transient Entry[] table;//存储元素的实体数组
2 
3 transient int size;//存放元素的个数
4 
5 int threshold; //临界值   当实际大小超过临界值时，会进行扩容threshold = 加载因子*容量
6 
7 final float loadFactor; //加载因子
8 
9 transient int modCount;//被修改的次数

　   其中加载因子是表示Hash表中元素的填满的程度.若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但:冲突的机会加大了.反之,加载因子越小,填满的元素越少,
好处是:冲突的机会减少了,但:空间浪费多了.冲突的机会越大,则查找的成本越高.反之,查找的成本越小.于是,查找时间就越小.所以,必须在 "冲突的机会"与"空间利用率"之间寻找一种平衡与折衷. 这种平衡与折衷本质上是数据结构中有名的"时-空"矛盾的平衡与折衷.

　　若是机器内存足够，而且想要提升查询速度的话能够将加载因子设置小一点；相反若是机器内存紧张，而且对查询速度没有什么要求的话能够将加载因子设置大一点。不过通常咱们都不用去设置它，让它取默认值0.75就行了。

　　下面看看HashMap的几个构造方法：

 1 public HashMap(int initialCapacity, float loadFactor) {
 2         //确保数字合法
 3         if (initialCapacity < 0)
 4             throw new IllegalArgumentException("Illegal initial capacity: " +
 5                                                initialCapacity);
 6         if (initialCapacity > MAXIMUM_CAPACITY)
 7             initialCapacity = MAXIMUM_CAPACITY;
 8         if (loadFactor <= 0 || Float.isNaN(loadFactor))
 9             throw new IllegalArgumentException("Illegal load factor: " +
10                                                loadFactor);
11 
12         // Find a power of 2 >= initialCapacity
13         int capacity = 1;   //初始容量
14         while (capacity < initialCapacity)   //确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂
15             capacity <<= 1;
16 
17         this.loadFactor = loadFactor;
18         threshold = (int)(capacity * loadFactor);
19         table = new Entry[capacity];
20         init();
21     }
22 
23     public HashMap(int initialCapacity) {
24         this(initialCapacity, DEFAULT_LOAD_FACTOR);
25     }
26 
27     public HashMap() {
28         this.loadFactor = DEFAULT_LOAD_FACTOR;
29         threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
30         table = new Entry[DEFAULT_INITIAL_CAPACITY];
31         init();
32     }

　　咱们能够看到在构造HashMap的时候若是咱们指定了加载因子和初始容量的话就调用第一个构造方法，不然的话就是用默认的。默认初始容量为16，默认加载因子为0.75。咱们能够看到上面代码中13-15行，这段代码的做用是确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂，至于为何要把容量设置为2的n次幂，咱们等下再看。

　　下面看看HashMap存储数据的过程是怎样的，首先看看HashMap的put方法：

 1 public V put(K key, V value) {
 2         if (key == null) //若是键为null的话，调用putForNullKey(value)
 3             return putForNullKey(value);
 4         int hash = hash(key.hashCode());//根据键的hashCode计算hash码
 5         int i = indexFor(hash, table.length);
 6         for (Entry<K,V> e = table[i]; e != null; e = e.next) { //处理冲突的，若是hash值相同，则在该位置用链表存储
 7             Object k;
 8             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //若是key相同则覆盖并返回旧值
 9                 V oldValue = e.value;
10                 e.value = value;
11                 e.recordAccess(this);
12                 return oldValue;
13             }
14         }
15 
16         modCount++;
17         addEntry(hash, key, value, i);
18         return null;
19     }

当咱们往hashmap中put元素的时候，先根据key的hash值获得这个元素在数组中的位置（即下标），而后就能够把这个元素放到对应的位置中了。若是这个元素所在的位子上已经存放有其余元素了，那么在同一个位子上的元素将以链表的形式存放，新加入的放在链头，最早加入的放在链尾。从hashmap中get元素时，首先计算key的hashcode，找到数组中对应位置的某一元素，而后经过key的equals方法在对应位置的链表中找到须要的元素。

具体的实现是：

当你的key为null时，会调用putForNullKey,HashMap容许key为null,这样的对像是放在table[0]中。

若是不为空，则调用int hash = hash(key.hashCode());这是hashmap的一个自定义的hash,在key.hashCode()基础上进行二次hash

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

获得hash码以后就会经过hash码去计算出应该存储在数组中的索引，计算索引的函数以下：

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

　这个方法很是巧妙，它经过 h & (table.length -1) 来获得该对象的保存位，而HashMap底层数组的长度老是 2 的n 次方，这是HashMap在速度上的优化。当length老是 2 的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，可是&比%具备更高的效率。当数组长度为2的n次幂的时候，不一样的key算得得index相同的概率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的概率小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了。

下面咱们继续回到put方法里面，前面已经计算出索引的值了，看到第6到14行，若是数组中该索引的位置的链表已经存在key相同的对象，则将其覆盖掉并返回原先的值。若是没有与key相同的键，则调用addEntry方法建立一个Entry对象，addEntry方法以下：

1 void addEntry(int hash, K key, V value, int bucketIndex) {
2         Entry<K,V> e = table[bucketIndex]; //若是要加入的位置有值，将该位置原先的值设置为新entry的next,也就是新entry链表的下一个节点
3         table[bucketIndex] = new Entry<>(hash, key, value, e);
4         if (size++ >= threshold) //若是大于临界值就扩容
5             resize(2 * table.length); //以2的倍数扩容
6     }

参数bucketIndex就是indexFor函数计算出来的索引值，第2行代码是取得数组中索引为bucketIndex的Entry对象，第3行就是用hash、key、value构建一个新的Entry对象放到索引为bucketIndex的位置，而且将该位置原先的对象设置为新对象的next构成链表。

　　第4行和第5行就是判断put后size是否达到了临界值threshold，若是达到了临界值就要进行扩容，HashMap扩容是扩为原来的两倍。resize()方法以下：

 1 void resize(int newCapacity) {
 2         Entry[] oldTable = table;
 3         int oldCapacity = oldTable.length;
 4         if (oldCapacity == MAXIMUM_CAPACITY) {
 5             threshold = Integer.MAX_VALUE;
 6             return;
 7         }
 8 
 9         Entry[] newTable = new Entry[newCapacity];
10         transfer(newTable);//用来将原先table的元素所有移到newTable里面
11         table = newTable;  //再将newTable赋值给table
12         threshold = (int)(newCapacity * loadFactor);//从新计算临界值
13     }

扩容是须要进行数组复制的，上面代码中第10行为复制数组，复制数组是很是消耗性能的操做，因此若是咱们已经预知HashMap中元素的个数，那么预设元素的个数可以有效的提升HashMap的性能。