在研究hashMap之前先了解下hashMap冲突处理采取的处理方式。因为hashMap对于冲突处理采用的是拉链法，所以对拉链法进行详解。其他后续再说。
一、哈希？散列表，根据key值快速访问value
二、哈希冲突解决
其中关于装填因子：
1、什么是装填因子？比如定义 16的散列空间，存放了12个关键字 那么此时装填因子α=0.75 即，装填因子表示hash表中存放元素的填满成都。
2、为啥装填因子越小越好？打个比方，房间大小一定，住的人越少越舒坦。参考原因在下边
大致看一下，无论哪一个处理装填因子越小成功查找的次数越少，不成功查找次数越多。所以尽量保证小一点的装填因子。
3、开散列与闭散列？开放定址法与拉链法的另一种叫法。开放定址法，在存储空间内（有界）进行散列，所以叫闭散列。同理拉链就叫闭散列，可以根据需要动态扩增。
参考 ：
三、
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);
// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}
capacity：容量
loadFactor:装载因子 默认0.75
threshold:最多容纳Entry的个数 threshold=capacity*loadFactor,如果元素多于，进行*2扩增。
关于Entry后续会新（增挖一个坑先）。
public V get(Object key) {
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());
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;
}
获取key对象的hashCode值，根据hashCode获取数组下标，根据下标获取链表值。遍历链表，取出hash值相等的value.
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
包含判断，其实现与get类似，取table下标中对应的链表。并且又是Entry
final Entry<K,V> getEntry(Object key) {
int hash = (key == null) ? 0 : hash(key.hashCode());
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 != null && key.equals(k))))
return e;
}
return null;
}
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
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;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
Q：hashMap的 get()方法工作原理。
使用put(key,value)存储数据时，调用hashCode()方法，返回hashCode值，获取存储痛bucket位置来存储Entry<K,V>对象。
从数组（通过hash值）取得链表头，然后通过equals比较key，如果相同，就覆盖老的值，并返回老的值。（该key在hashmap中已存在）
否则新增一个entry，返回null。新增的元素为链表头，以前相同数组位置的挂在后面。
另外：modCount是为了避免读取一批数据时，在循环读取的过程中发生了修改，就抛异常
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}
新增超值，resize,重新分配数组处理，将老数组数据转移新数组。
上面程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。从上面程序中可以看出：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。这也说明了前面的结论：我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里.
java中动态扩增由此惯例。
比如ArrayList里的数组扩容，使用的是System.arrayCopy调用，这是一个native方法，在java层面创建一个新的长度的数组，然后将老数组和新数组都传进去，在native里将老数组里的元素指针拷贝到新数组里。
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}
