为什么需要哈希表？
举个例子（摘自漫画算法）：
在上学时需要学习英语，而在当时有很多的电子词典，同学们遇到不会的单词，只要在这个电子词典上输入单词的英文，就可以查出中文的含义。
当时的英语老师强烈反对使用这样的工具，因为电子词典查出来的中文资料太有限，而传统的纸质词典可以查到单词的多种含义、词性、例句等。
但是，同学们还是倾向于使用电子词典。因为电子词典实在太方便了，只要输入要查找的单词，一瞬间就可以得到结果，而不需要像纸质词典那样繁琐地进行人工查找。
在我们程序员的世界里，往往也需要在内存中存放这样一个“词典”，方便我们进行高效的查询和统计。
例如开发一个学生管理系统，需要有通过输入学号快速查出对应学生的姓名的功能。这里不必每次都去查询数据库，而可以在内存建立一个缓存表，这样做可以提高查询效率。
| 学号 | 姓名 |
|---|---|
| 10001 | 张三 |
| 10002 | 李四 |
| 10003 | 王五 |
| 10004 | 赵六 |
再如我们需要统计一本英文书里某些单词出现的频率，就需要遍历整本书的内容，把这些单词出现的次数记录在内存中。
| 单词 | 出现次数 |
|---|---|
| this | 56 |
| and | 87 |
| are | 98 |
| by | 46 |
因为这些需求，一个重要的数据结构诞生了，这个数据结构就叫做散列表。
散列表也叫做哈希表，这种数据结构提供了键和值的映射关系。只要给出key，就可以高效的查找所对应的值。
| key | value |
|---|---|
| key1 | value1 |
| key2 | value2 |
| key3 | value3 |
| key4 | value4 |
那么，散列表是如何根据key来快速查找到所匹配的value呢？
哈希函数
散列表在本质上是一个数组，为什么底层使用数组呢？
数组的特点是它的随机访问能力，根据索引来进行访问，所以我们需要一个“中转站”，通过某种方式，把键转换为索引，而这个中转站就叫做哈希函数。
那么这个所谓的哈希函数是如何实现的呢？
在不同的语言中，哈希函数的实现方式是不一样的。这里以Java的常用集合HashMap为例，来看一看哈希函数在Java中的实现。
在Java及大多数面向对象的语言中，每一个对象都有属于自己的hashcode，这个hashcode是区分不同对象的标识。无论对象自身类型是什么，它们的hashcode都是一个整型变量。
既然都是整型变量，想要转换成数组的索引也就不难实现了。最简单的转换方式就是按照数组的长度进行取模。
通过哈希函数，我们可以把字符串或其他类型的键转换为数组的索引。
例如：给出一个长度为10的数组，当key=24321时，index=HashCode("24321") % Array.length。
哈希表的实现
1、写操作
写操作就是在哈希表中插入新的元素。分为两个步骤：
第一步：通过哈希函数，把key转化为数组的索引
第二步：如果当前key所对应的索引中没有元素，就把新元素添加进去。
注意：由于数组的长度是有限的，当插入的元素越来越多，我们很难保证每一个键通过哈希函数转换
为对应不同的索引，在这种情况下，我们不得不处理一个在哈希表中关键的问题，两个不同的键，通过哈希函数转换为同一个索引，这种情况称为哈希冲突，这也是哈希表中最复杂的。
解决方式：
-
开放寻址法
开放寻址法很简单，当一个键通过哈希函数转换为索引并且这个索引已被占用时，我们可以“另谋高就”，寻找下一个空档的位置。
例如，newKey通过哈希函数转换为索引2，该索引在数组中已经被占用了，那么就向后移动一位，看看索引为3的位置是否被占用了，如果占用了，那么继续向后移动一位，看看索引为4的位置是否被占用了，如果没有占用，就把key3存放到数组索引为4的索引。
如图：
这就是开放寻址法的基本思路。当然，如果遇到哈希冲突时，寻址方式有很多种，在这里只是简单的举个例子。
-
链地址法
链地址法说白就是一个链表的数组，数组当中每一个元素都是一个链表，当遇到哈希冲突时，只需要插入对应的链表即可。
2、读操作
读操作就是通过给定的键，在哈希表中查找对应的值。分为两个步骤：
第一步：通过哈希函数，把键转换为索引。
第二步：通过索引找到对应的元素，再比较键，如果键相等，那么就找到了，如果不相等，继续找。
3、扩容
由于哈希表的底层实际上就是个数组，那么哈希表也就要涉及到扩容的问题了。
首先，什么时候需要进行扩容呢？
当经过多次写操作时，哈希表达到一定的饱和度时，键映射位置发生冲突的概率会逐渐提高。这样一来，大量的元素拥挤在相同的数组索引位置，会形成很长的链表，对后续的写操作和读操作的性能会造成很大的影响。这时，哈希表就需要扩展它的长度，也就是进行扩容。
扩容分为两个步骤：
-
扩容
创建一个新的数组，并且新的数组的长度是原来的数组的2倍。
-
重新Hash
遍历原数组，把所有的元素重新Hash到新数组当中。
注意：在Java中，关于HashMap的实现，在Java8之前HashMap的实现每个位置对应着一个链表。不过，从Java8开始有了一个改变，在初始的时候哈希表的每个位置依然是一个链表，但是，当哈希冲突达到一定的程度时，会把哈希表中的每一个位置从链表转成红黑树！
整体代码如下（在这里哈希冲突的解决方式使用的是链地址法，只不过把链表替换为了红黑树）：
/**
* 描述：哈希表（通过红黑树解决哈希冲突问题）
* <p>
* Create By ZhangBiao
* 2020/5/12
*/
public class HashTable<K, V> {
private static final int UPPER_TOL = 10;
private static final int LOWER_TOL = 2;
private static final int INIT_CAPACITY = 7;
private TreeMap<K, V>[] hashtable;
private int size;
private int M;
public HashTable(int M) {
this.M = M;
this.size = 0;
this.hashtable = new TreeMap[M];
for (int i = 0; i < M; i++) {
hashtable[i] = new TreeMap<>();
}
}
public HashTable() {
this(INIT_CAPACITY);
}
private int hash(K key) {
return (key.hashCode() & 0x7fffffff) % M;
}
public int getSize() {
return size;
}
public void add(K key, V value) {
TreeMap<K, V> map = hashtable[hash(key)];
if (map.containsKey(key)) {
map.put(key, value);
} else {
map.put(key, value);
size++;
if (size >= UPPER_TOL * M) {
resize(2 * M);
}
}
}
private void resize(int newM) {
TreeMap<K, V>[] newHashTable = new TreeMap[newM];
for (int i = 0; i < newM; i++) {
newHashTable[i] = new TreeMap<>();
}
int oldM = this.M;
this.M = newM;
for (int i = 0; i < oldM; i++) {
for (K key : hashtable[i].keySet()) {
newHashTable[hash(key)].put(key, hashtable[i].get(key));
}
}
this.hashtable = newHashTable;
}
public V remove(K key) {
V ret = null;
TreeMap<K, V> map = hashtable[hash(key)];
if (map.containsKey(key)) {
ret = map.remove(key);
size--;
if (size <= LOWER_TOL * M && M > INIT_CAPACITY) {
resize(M / 2);
}
}
return ret;
}
public void set(K key, V value) {
TreeMap<K, V> map = hashtable[hash(key)];
if (!map.containsKey(key)) {
throw new IllegalArgumentException(key + "doesn't exist!");
}
map.put(key, value);
}
public boolean contains(K key) {
return hashtable[hash(key)].containsKey(key);
}
public V get(K key) {
return hashtable[hash(key)].get(key);
}
}