浅析HashMap的实现
预备知识：
查找：根据输入的值在指定的数组中查找其是否存在。
基本的查找可以为：
在有序的数组中：折半查找
在无序数组中：顺序查找（改进的顺序查找：如果待查数组有规律，在查到某个位置后不再进行查找，从而减少查找次数）
Hash法：将待查数据经过hash函数计算后，得到存储位置，存放在指定位置。在查找时只需要计算就可得到是否存在某个元素（这里不讨论冲突的发生，及处理冲突的方法）。
Hash函数：根据指定值计算相应的hash值。
Hash函数的基本常见函数：数字分析法（根据数字本身的特性进行位置的确定）、除留余数法（将输入的值和不大于待散列数组的最大质数进行取余确定位置）、平方取中法（将数字去平方后，选择平方后的数字的中间部分）等
Hash产生冲突的原因：经过hash函数后的值有相同的。这是不可避免的，只能尽量减少。
冲突处理方法：
① 开放定址：线性探测再散列、随机探测等。优点：易于实现。缺点：增加了冲突的可能性，导致随后的冲突率增加；在查找过程中增加了查找次数。
② 拉链法：为每个冲突的元素创建一个结点，数据部分存放元素，指针部分指向下一个冲突元素的结点。优点：不会影响随后的元素插入。缺点：增加了内存开销。注意：JAVA中的HashMap和Oracle数据库中对于有相同hashcode值的数据存放采用的就是这个方式。
填充率：元素个数和数组长度的比值称为填充率。它是衡量一个hash函数好坏的标志之一，另外可以在达到某些值后进行长度的扩充，减少冲突。
HashMap：利用键值对存放数据。形式<Key k,Value v>。这里键值要求唯一，如果在插入过程中插入有相同的Key的键值对，会导致原来键值对中的值域部分被改变，从而引起数据的不一致。
下面解读HashMap的部分源码。
类之间的关系就不在一一赘述。差API知道，HashMap继承AbstractMap,实现了Map接口,Map接口定义了所有Map子类必须实现的方法。HashMap继承的父类和实现的接口和Set及List不同，它没有实现Collection接口。
HashMap的实例有两个参数影响其性能：初始容量和加载因子。初始容量只是哈希表在创建时的容量。加载因子是哈希表再其容量自动增加之前可以达到多满的一种尺度。当哈希表中的元素个数超出了加载因子与当前容量的乘积时，则要对该哈希表进行rehash操作（扩容操作）。
HashMap中定义的属性：
2 //默认的初始容量16.
4 static final int DEFAULT_INITIAL_CAPACITY = 16;
6 //最大容量，也就是2的30次幂（假设这里采用补码存储数字）
8 static final intMAXIMUM_CAPACITY = 1 << 30;
10 //默认装填因子0.75（公式为：元素个数和table长度的比值）.
12 static final float DEFAULT_LOAD_FACTOR = 0.75f;
14 //存储数据的Entry数组
16 transient Entry[] table;
18 // map中保存的键值对的数量，也就是元素的个数
20 transient int size;
21
22 // 需要调整大小的极限值（容量*装载因子）
24 int threshold;
25
26 //装载因子,当HashMap的数据大小>=容量*加载因子时，HashMap会将容量扩容
28 final float loadFactor;
29
30 // map结构被改变的次数，基本没怎么使用
32 transient volatile int modCount;
HashMap的构造方法。
//使用默认的容量及装载因子构造一个空的HashMap
4 public HashMap() {
5 this.loadFactor = DEFAULT_LOAD_FACTOR;
6 threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
7 table = new Entry[DEFAULT_INITIAL_CAPACITY];//根据默认容量初始化table
8 init();
9 }
11 //根据给定的初始容量的装载因子创建一个空的HashMap
12 //初始容量小于0或装载因子小于等于0将报异常
14 public HashMap(int initialCapacity, float loadFactor) {
15 if (initialCapacity < 0)
16 throw new IllegalArgumentException("Illegalinitial capacity: " +
17 initialCapacity);
18 if (initialCapacity > MAXIMUM_CAPACITY)
19 initialCapacity =MAXIMUM_CAPACITY;
20 if (loadFactor <= 0 || Float.isNaN(loadFactor))
21 throw newIllegalArgumentException("Illegal load factor: " +
22 loadFactor);
23 int capacity = 1;
24 //设置capacity为大于initialCapacity且是2的幂的最小值
25 while (capacity < initialCapacity)
26 capacity <<= 1;
27 this.loadFactor = loadFactor;
28 threshold = (int)(capacity * loadFactor);
29 table = new Entry[capacity];
30 init();
31 }
32
33 //根据指定容量创建一个空的HashMap，这里装填因子为默认值0.75f
35 public HashMap(int initialCapacity) {
36 this(initialCapacity, DEFAULT_LOAD_FACTOR);
38 //通过传入的map创建一个HashMap，容量为默认容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者。
41 public HashMap(Map<? extends K, ? extends V> m) {
42 this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
43 DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
44 putAllForCreate(m);
45 }
注意：在第二个构造方法中，capacity才是初始容量，而不是initialCapacity，即如果执行new HashMap(9,0.75),那么HashMap的初始容量是16，而不是9。根据装填因子的公式可知：数组长度为：元素个数除以装填因子。
在初始化table的时候都使用了Entry,这是HashMap的一个内部类。Map.Entry接口定义的方法：K getKey();V getValue();VsetValue();boolean equals(Object o);int hashCode();
HashMap.Entry类的具体实现
1static 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;//每个key的hash值唯一，不能被改变
7 Entry(int h, K k, V v, Entry<K,V> n) {
8 value = v;
9 next = n;
10 key = k;
11 hash = h;
12 }
13
14 public final K getKey() {
15 return key;
16 }
17
18 public final V getValue() {
19 return value;
20 }
21
22 public final V setValue(V newValue) {
23 V oldValue =value;
24 value = newValue;
25 return oldValue;//返回的是之前的Value
26 }
27
28 public final boolean equals(Object o) {
29 if (!(o instanceof Map.Entry))//先判断类型是否一致
30 return false;
31 Map.Entry e = (Map.Entry)o;
32 Object k1 = getKey();
33 Object k2 = e.getKey();
34 // Key相等且Value相等则两个Entry相等，如果hash值也等，则冲突。
35 if (k1 == k2 || (k1 != null&& k1.equals(k2))) {
36 Object v1 = getValue();
37 Object v2 = e.getValue();
38 if (v1 == v2 || (v1 != null&& v1.equals(v2)))
39 return true;
40 }
41 return false;
42 }
43 // hashCode是Key的hashCode和Value的hashCode的异或的结果
44 public final int hashCode() {
45 return (key==null ? 0 : key.hashCode()) ^
46 (value==null ? 0 :value.hashCode());
47 }
48 // 重写toString方法，是输出更清晰
49 public final String toString() {
50 return getKey() + "=" +getValue();
51 }
52
56 void recordAccess(HashMap<K,V> m) {
57 }
58
62 void recordRemoval(HashMap<K,V> m) {
63 }
64 }
put()方法剖析：
1public V put(K key, V value) {
2 if (key == null)
3 return putForNullKey(value);
4 int hash = hash(key.hashCode());//得到key的hash值，这个值不是索引位置
5 int i = indexFor(hash, table.length);//根据hash值和table的长度得到在table的位置
6 for (Entry<K,V> e = table[i]; e != null; e = e.next) {//这里得到在table的i位置上的e,如果e不为空，则说明该位置上有元素，那么判断输入
//的键值对的hash码及其equals方法是否相等，如果相等，说明输入的元素的key值和已存在的相等，那么将它的value覆盖原来的value。
7 Object k;
8 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
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 }当待put的key为null的时候会调用putForNullKey(value)方法,暂且绕过，先来看看如何hash。HashMap并 不是直接将对象的hashcode作为哈希值，而是把key的hashcode做一些运算以得到最终的哈希值，而且得到的哈希值也不是在数组中的位置，无 论是get还是put还是别的方法，计算哈希值都是：
1 int hash = hash(key.hashCode());
1 static int hash(int h) {
2 // This function ensures that hashCodes that differ only by
3 // constant multiples at each bit position have a bounded
4 // number of collisions (approximately 8 at default load factor).
5 h ^= (h >>> 20) ^ (h >>> 12);
6 return h ^ (h >>> 7) ^ (h >>> 4);
7 }hash方法为什么要这样取值，有待探讨，但是作用肯定是防止冲突。如何确定数据在数组中的位置：
1 int hash = hash(k.hashCode());
2 int i = indexFor(hash,table.length);第一行，得到哈希值，第二行，根据哈希值计算元素在数组中的位置。
1 static int indexFor(int h,int length){
2 return h & (length - 1);
3 }"h&(length-1)"是一个进行与的运算。
首先我们要确定，HashMap的数组长度永远是偶数，所以length-1一定是一个奇数，假设现在的长度是16，length-1就是15，对应的二进制是：1111。
假设有两个元素，一个哈希值是8，二进制是1000，一个哈希值是9，二进制是1001。和1111与运算后，分别还是1000和1001，他们被分配在了数组的不同位置，这样，哈希的分布非常均匀。
那么如果数组的长度是奇数，减去1后就是偶数了，偶数对应的二进制最低位一定是0，例如14二进制1110。对上面两个数字分别与运算，得到 1000和1000。这样，哈希值8和9的元素会被存储在数组同一个位置的链表中。在操作的时候，链表中的元素越多，效率就会越低，因为要不停的对链表循环比较。
在找到元素在数组中的索引位置以后，会循环遍历table[i]所在的链表，如果找到key值与传入的key值相同的对象，则替换并返回原对象；若找不到，则通过addEntry(hash,key,value,i)添加新的对象。
1 void addEntry(int hash, K key, V value,int bucketIndex) { Entry<K,V>e = table[bucketIndex];
2 table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
3 if (size++ >= threshold)
4 resize(2 *table.length);
5 }以上过程就是新建一个Entry对象，并放在当前位置的Entry链表的头部。然后判断size是否达到了需要扩容的界限并让size增加1，如果达到了扩容的界限则调用resize(int capacity)方法。
1void resize(int newCapacity) {
2 Entry[] oldTable = table;
3 int oldCapacity = oldTable.length;
4 // 这个if块表明，如果容量已经到达允许的最大值，即MAXIMUN_CAPACITY，则不再拓展容量，而将装载拓展的界限值设为计算机允许的最大值。
5 // 不会再触发resize方法，而是不断的向map中添加内容，即table数组中的链表可以不断变长，但数组长度不再改变
6 if (oldCapacity == MAXIMUM_CAPACITY) {
7 threshold = Integer.MAX_VALUE;
8 return;
9 }
10 // 创建新数组，容量为指定的容量
11 Entry[] newTable = new Entry[newCapacity];
12 transfer(newTable);
13 table = newTable;
14 // 设置下一次需要调整数组大小的界限
15 threshold = (int)(newCapacity * loadFactor);
16 }这里需要重点看看transfer方法：
1void transfer(Entry[] newTable) {
2 // 保留原数组的引用到src中，
3 Entry[] src = table;
4 // 新容量使新数组的长度
5 int newCapacity = newTable.length;
6 // 遍历原数组
7 for (int j = 0; j < src.length; j++) {
8 // 获取元素e
9 Entry<K,V> e = src[j];
10 if (e != null) {
11 // 将原数组中的元素置为null
12 src[j] = null;
13 // 遍历原数组中j位置指向的链表
14 do {
15 Entry<K,V> next = e.next;
16 // 根据新的容量计算e在新数组中的位置
17 int i = indexFor(e.hash,newCapacity);
18 // 将e插入到newTable[i]指向的链表的头部
19 e.next = newTable[i];
20 newTable[i] = e;
21 e = next;
22 } while (e != null);
23 }
24 }
25 }tranfer方法将所有的元素重新哈希，因为新的容量变大，所以每个元素的哈希值和位置都是不一样的。
如果key值为空，我们来看看putForNullKey的处理过程：
1private V putForNullKey(V value) {
2 for (Entry<K,V> e = table[0]; e != null; e = e.next) {
3 if (e.key == null) {
4 V oldValue = e.value;
5 e.value = value;
6 e.recordAccess(this);
7 return oldValue;
8 }
9 }
10 modCount++;
11 addEntry(0, null, value, 0);
12 return null;
13 }这是一个私有方法，在put方法中被调用。它首先遍历table数组，如果找到key为null的元素，则替换值并返回oldValue；否则通过addEntry方法添加元素，并返回null。
正确的使用HashMap
1.不要再并发场景中使用HashMap
HashMap是线程不安全的，如果被多个线程共享的操作，将会引发不可预知的问题。据sun的说法，在扩容时，会引起链表的闭环，在get元素时，就会无限循环。
1public V get(Object key) {
2 if(key == null)
3 return getForNullKey();
4 int hash = hash(key.hashCode());
5 for (Entry<K,V> e = table[indexFor(hash, table.length)];
6 e != null;
7 e = e.next) {
8 Object k;
9 if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
10 return e.value;
11 }
12 return null;
13 }
