Map 是非常常用的一种数据接口。在 Java 中，提供了成熟的 Map 实现。
图 1
最主要的实现类有 Hashtable、HashMap、LinkedHashMap和 TreeMap。在 HashTable 的子类中，还有 Properties的实现。Properties 是专门读取配置文件的类，我们会在稍后介绍。这里首先值得关注的是 HashMap 和 HashTable 两套不同的实现，两者都实现了 Map 接口。从表面上看，并没有多大差别，但是在内部实现上却有些微小的细节。
首先，HashTable 的大部分方法都做了同步，而 HashMap 没有，因此， HashMap 不是线程安全的。
其次，HashTable 不允许 key 或者 value 使用 null 值，而 HashMap 可以。
第三，在内部实现算法上，它们对 key 的 hash 算法和 hash 值到内存索引的映射算法不同。
虽然有诸多不同，但是他们的性能确实相差无几。由于 HashMap 使用广泛性，现以 HashMap 为例，阐述它的实现机理。
HashMap 内部维护一个数组，并且将 key 做 hash 算法，然后将 hash 值映射到内存地址，即数组的下标索引，这样就可以通过key直接取到所对应的数据。而对于发生碰撞的位置，则会维护一个链表，所有在同一位置发生碰撞的元素都会存放在同一位置的链表中。
图 2
如图 2，数组中的每一个元素都是一个 Entry 实例：
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
//.....省略部分
}
每一个实例都包含 元素key, 元素value , 元素hash值，以及指向下一个在当前位置发生冲突的 Entry实例。
下面我们来看一下最基本的put 操作。
/*
* 将（key, value）放入 map
*/
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
// 计算 key 对应的下标 。关于 hash 和 indexFor 方法，我们会在后面讲到。
int hash = hash(key);
int i = indexFor(hash, table.length);
// 如果发生了冲突，那么就遍历当前冲突位置的链表。如果在链表中发现该元素已经存在(即两元素的 key 和 hash
// 值一样)，则用新值替换原来的值，并返回原来的值。
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;
// 将该元素的访问存入历史记录中（在LinkedHashMap才发挥作用）
e.recordAccess(this);
return oldValue;
}
}
// 标志容器被修改次数的计数器，在使用迭代器遍历时起作用
modCount++;
// 为新值创建一个新元素，并添加到数组中
addEntry(hash, key, value, i);
return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
// 如果数组需要扩容，则进行扩容
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
// 创建新元素并添加到数组中
createEntry(hash, key, value, bucketIndex);
}
/*
* 创建新元素，并将该新元素加到下标位置的最前端，该新元素的next引用指向该位置原来的元素（如果有）
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K, V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
应经加上了详细的注释，相信大家都能读得懂。同样的，get 操作就比这个简单多了，笔者就不再啰嗦了，下面直接将最关键的部分。
HashMap的高性能需要保证以下几点：
1、hash 算法必须是高效的
2、hash 值到内存地址（数组索引）的算法是快速的
3、根据内存地址（数组索引）可以直接取得对应的值
首先来看第一点，hash 算法的高效性，在 HashMap 中，put() 方法和 hash 算法有关代码如下：
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
//...........省略部分
}
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
h ^= k.hashCode();
// 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);
} HashMap的功能是通过“键(key)”能够快速的找到“值”。下面我们分析下HashMap计算下标索引的思路： 1、 当调用put(key,value)时，首先获取key的hashcode，int hash = key.hashCode();
2、 再把hash通过一下运算得到一个int h。
hash ^= (hash >>> 20) ^ (hash >>> 12);
int h = hash ^ (hash >>> 7) ^ (hash >>> 4);
为什么要经过这样的运算呢？这就是HashMap的高明之处。先看个例子，一个十进制数32768(二进制1000 0000 0000 0000)，经过上述公式运算之后的结果是35080(二进制1000 1001 0000 1000)。看出来了吗？或许这样还看不出什么，再举个数字61440(二进制1111 0000 0000 0000)，运算结果是65263(二进制1111 1110 1110 1111)，现在应该很明显了，它的目的是让“1”变的均匀一点，散列的本意就是要尽量均匀分布。假设key.hashCode()的值为：0x7FFFFFFF， table.length为默认值16。它的详细运行过程如下图 3 所示。
图 3
3、 得到h之后，下一步便要解决，怎样通过 h ，得到元素的数组下标。
前面说过hashmap的底层采用数组盛放数据，所以我们当然希望这个hashmap里面的元素位置尽量的分布均匀些，尽量使得每个位置上的元素数量只有一个，这样当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，而不用再去遍历链表。 所以我们首先想到最简单的办法就是把hashcode对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。这也是 HashTable 采用的策略，HashTable中的算法只是把key的 hashcode与length相除取余，即hash % length，这样有可能会造成index分布不均匀。而且，“模”运算的消耗还是比较大的，能不能找一种更快速，消耗更小的方式那？java中是这样做的：
/**
* Returns index for hash code h.
*/
static int indexFor(int h, int length) {
return h & (length-1);
}
将取得的 h 跟数组的长度-1做一次“与”运算（&）。看上去很简单，其实比较有玄机。比如数组的长度是2的4次方，那么hashcode就会和2的4次方-1做“与”运算。很多人都有这个疑问，为什么hashmap的数组初始化大小都是2的次方大小时，hashmap的效率最高，我以2的4次方举例，来解释一下为什么数组大小为2的幂时hashmap访问的性能最高。
看下图 4，左边两组是数组长度为16（2的4次方），右边两组是数组长度为15。两组的hashcode均为8和9，但是很明显，当它们和1110“与”的时候，产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到同一个链表上，那么查询的时候就需要遍历这个链表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hashcode的值会与14（1110）进行“与”，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个末尾都为1
的位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！
图 4
所以说，当数组长度为2的n次幂的时候，不同的key算得得index相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了。
说到这里，我们再回头看一下hashmap中默认的数组大小是多少，查看源代码可以得知是16，为什么是16，而不是15，也不是20呢，看到上面annegu的解释之后我们就清楚了吧，显然是因为16是2的整数次幂的原因，在小数据量的情况下16比15和20更能减少key之间的碰撞，而加快查询的效率。
所以，在存储大容量数据的时候，最好预先指定hashmap的size为2的整数次幂次方。就算不指定的话，也会以大于且最接近指定值大小的2次幂来初始化的。
当hashmap中的元素越来越多的时候，碰撞的几率也就越来越高（因为数组的长度是固定的），所以为了提高查询的效率，就要对hashmap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，所以这是一个通用的操作，很多人对它的性能表示过怀疑。在hashmap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。
那么hashmap什么时候进行扩容呢？当hashmap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，也就是说，默认情况下，数组大小为16，那么当hashmap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知hashmap中元素的个数，那么预设元素的个数能够有效的提高hashmap的性能。比如说，我们有1000个元素new HashMap(1000), 但是理论上来讲new HashMap(1024)更合适，不过上面annegu已经说过，即使是1000，hashmap也自动会将其设置为1024。 但是new HashMap(1024)还不是更合适的，因为0.75*1000 < 1000, 也就是说为了让0.75 * size > 1000, 我们必须这样new HashMap(2048)才最合适，既考虑了&的问题，也避免了resize的问题。
本文主要描述了HashMap的结构，put 操作的详细实现，hashmap中hash函数的实现，以及该实现的特性，同时描述了hashmap中resize带来性能消耗的根本原因。尤其是hash函数的实现，可以说是整个HashMap的精髓所在，只有真正理解了这个hash函数，才可以说对HashMap有了一定的理解。
转载请注明原文地址：http://blog.csdn.net/zq602316498/
本文部分内容和图片来自于网络
深入理解 hash 函数、HashMap、LinkedHashMap、TreeMap 【上】
原文地址：http://blog.csdn.net/zq602316498/article/details/39351363
