hashMap（一）——拉链法冲突处理与hashMap源码分析

在研究hashMap之前先了解下hashMap冲突处理采取的处理方式。因为hashMap对于冲突处理采用的是拉链法，所以对拉链法进行详解。其他后续再说。

一、哈希？散列表，根据key值快速访问value

二、哈希冲突解决

1、开放定址法

  a、线性探查法

  b、线性补偿探查法

  c、随机探测

 2、拉链法
拉链法数据结构参考

 （1）拉链法解决冲突的做法是：将所有关键字为同义词的结点链接在同一个单链表中。若选定的散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点，均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链法中，装填因子α可以大于1，但一般均取α≤1

 （2）拉链法的优点

    　与开放定址法相比，拉链法有如下几个优点：

　　(1)拉链法处理冲突简单，且无堆积现象，即非同义词决不会发生冲突，因此平均查找长度较短；

　　(2)由于拉链法中各链表上的结点空间是动态申请的，故它更适合于造表前无法确定表长的情况；

　　(3)开放定址法为减少冲突，要求装填因子α较小，故当结点规模较大时会浪费很多空间。而拉链法中可取α≥1，且结点较大时，拉链法中增加的指针域可忽略不计，因此节省空间；

　　(4)在用拉链法构造的散列表中，删除结点的操作易于实现。只要简单地删去链表上相应的结点即可。而对开放地址法构造的散列表，删除结点不能简单地将被删结点的空间置为空，否则将截断在它之后填人散列表的同义词结点的查找路径。这是因为各种开放地址法中，空地址单元(即开放地址)都是查找失败的条件。因此在用开放地址法处理冲突的散列表上执行删除操作，只能在被删结点上做删除标记，而不能真正删除结点。

（3）拉链法的缺点 　拉链法的缺点是：指针需要额外的空间，故当结点规模较小时，开放定址法较为节省空间，而若将节省的指针空间用来扩大散列表的规模，可使装填因子变小，这又减少了开放定址法中的冲突，从而提高平均查找速度

其中关于装填因子：

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);
}