HashMap中的散列函数、冲突解决机制和rehash
一、概述
散列算法有两个主要的实现方式：开散列和闭散列，HashMap采用开散列实现。
HashMap中，键值对（key-value）在内部是以Entry（HashMap中的静态内部类）实例的方式存储，散列表table是一个Entry数组，保存Entry实例。
对于冲突的情况，在开散列中，如果若干个entry计算得到相同散列地址（具体是由indexFor(hash(key.hashCode()),length)求得），这些entry被组织成一个链表，并以table[i]为头指针。
HashMap的数据结构大致可以用下图表示（以HashMap<String,String>的实例为例）：
二、散列函数
HashMap采用简单的除法散列，其散列公式可表示为：
一般来讲，采用除法散列，m的值应该尽量避免某些特殊值，例如m不应该为2的幂。
如果m=2^p，那么h(k)的结果就是k的p个最低位，这样就会与k的比特位产生关联，更容易产生冲突，不能很好的保证散列函数的结果在[0...m-1]之间均匀分布。所以除非已知各种最低p为排列是等可能的，否则m选择应该考虑到关键字的所有位。
但是HashMap中提供了hash(int h)函数，这个函数以key.hashCode为参数，对其做进一步的处理，处理过程中较好的解决了以上的因素的影响。大致保证了每一个hashCode具有有限的冲突次数（通过移位运算和异或操作具体怎么达到这个目的？我也没有在深入去挖，感兴趣的同学可以来一起探讨学习下。。。）。
这样一来，某个key散列地址计算过程实际就是:
indexFor(hash(key.hashCode()),length)
可见，这里的hash(key.hashCode())结果相当于上面的散列公式中的k，lenght相当于m。
以下为hash(int h)和indexFor(int h, int length)源代码，更能说明问题：
/** * Applies a supplemental hash function to a given hashCode, which * defends against poor quality hash functions. This is critical * because HashMap uses power-of-two length hash tables, that * otherwise encounter collisions for hashCodes that do not differ * in lower bits. Note: Null keys always map to hash 0, thus index 0. */ static int hash(int h) { // This function ensures that hashCodes that differ only by // constant multiples at each bit position have a bounded // number of collisions (approximately 8 at default load factor). h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); } /** * Returns index for hash code h. */ static int indexFor(int h, int length) { return h & (length-1); }
注意indexFor(int h, int length)的处理方式：
在length为2的幂的情况下，h & (length-1) 等效于h%length。这里length为table的长度，HashMap保证了无论是在初始化时还是在后续resize操作过程中，length都是2的幂。
三、冲突解决机制
在需要插入<key,value>键值对（内部对应插入Entry实例）时，执行put操作。
两个相同的key必然计算出相同的散列地址（相同的indexFor(hash, table.length)结果），HashMap中不接受相同的key，对原有的key进行put操作实际上是进行覆盖value的操作。
两个不同的key仍有可能计算出相同的散列地址（例如前例中key为"d"和"u"），此时产生冲突。
HashMap中的冲突解决机制比较简单，将这些冲突的entry节点以链表的方式挂靠到table[i]处。插入时以参数(hash, key, value, e)创建新的Entry实例，e就是位于table[i]处的链表的第一个entry节点，e作为新创建的entry的next元素，所以新创建的entry直接插入到了链表的头部充当新的头结点。
从源代码层面分析来看，put操作调用addEntry()方法，后者继续调用HashMap中静态内部类Entry<K,V>的构造函数。
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; } 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); } static class Entry<K,V> implements Map.Entry<K,V> { ... /** * Creates new entry. */ Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; } ... }
四、rehash
当键值对的数量>=设定的阀值(capacity * load factor(0.75))时，为保证HashMap的性能，会进行重散列(rehash)。
HashMap中，重散列主要有两步：1、扩充table长度。2、转移table中的entry，从旧table转移到新的table。
table长度以2倍的方式扩充，一直到最大长度2^30。
entry转移的过程是真正意义上的重散列，在此过程中，对原来的每个entry的key重新计算新的散列地址，旧table中相同位置的entry极有可能会被散列到新table中不同的位置，这主要是因为table的length变化的原因。
在源代码中主要涉及resize()和transfer()两个方法。
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); } /** * Transfers all entries from current table to newTable. */ void transfer(Entry[] newTable) { Entry[] src = table; int newCapacity = newTable.length; for (int j = 0; j < src.length; j++) { Entry<K,V> e = src[j]; if (e != null) { src[j] = null; do { Entry<K,V> next = e.next; int i = indexFor(e.hash, newCapacity); e.next = newTable[i]; newTable[i] = e; e = next; } while (e != null); } } }
五、一些总结
1、capacity（table数组长度）必须为2的幂，初始容量（initial capacity）默认为16。即使是以传入参数initialCapacity的方式构造实例（HashMap(int initialCapacity, float loadFactor)），构造过程中内部也会将capacity修整为与initialCapacity最接近并且不小于它的2的幂的数作为capacity来实例化。
2、装填因子loadFactor默认为0.75。
3、如果key为null，这始终会被散列到table[0]的桶中，即使是rehash的过程也是一样。非null的key也有可能会被散列到table[0]的位置，例如上图中key=“f”，而且相同的key在在不同的时间可能会被散列到不同的位置，这与rehash有关。
4、HashMap以链表的方式解决冲突，插入键值对（put操作）时，新增的entry会被插入到链表的头部，也就是会插入到table[i]的位置。
5、与其他集合类一样，由于fail-fast特性的存在，利用遍历器（Iterator）进行遍历操作时应该采用遍历器自身的方法进行结构化的修改（例如remove操作），不应采用其他方式对其数据内容进行修改。
