为什么需要哈希表？

举个例子（摘自漫画算法）：

在上学时需要学习英语，而在当时有很多的电子词典，同学们遇到不会的单词，只要在这个电子词典上输入单词的英文，就可以查出中文的含义。

当时的英语老师强烈反对使用这样的工具，因为电子词典查出来的中文资料太有限，而传统的纸质词典可以查到单词的多种含义、词性、例句等。

但是，同学们还是倾向于使用电子词典。因为电子词典实在太方便了，只要输入要查找的单词，一瞬间就可以得到结果，而不需要像纸质词典那样繁琐地进行人工查找。

在我们程序员的世界里，往往也需要在内存中存放这样一个“词典”，方便我们进行高效的查询和统计。

例如开发一个学生管理系统，需要有通过输入学号快速查出对应学生的姓名的功能。这里不必每次都去查询数据库，而可以在内存建立一个缓存表，这样做可以提高查询效率。

再如我们需要统计一本英文书里某些单词出现的频率，就需要遍历整本书的内容，把这些单词出现的次数记录在内存中。

因为这些需求，一个重要的数据结构诞生了，这个数据结构就叫做散列表。

散列表也叫做哈希表，这种数据结构提供了键和值的映射关系。只要给出key，就可以高效的查找所对应的值。

那么，散列表是如何根据key来快速查找到所匹配的value呢？

哈希函数

散列表在本质上是一个数组，为什么底层使用数组呢？

数组的特点是它的随机访问能力，根据索引来进行访问，所以我们需要一个“中转站”，通过某种方式，把键转换为索引，而这个中转站就叫做哈希函数。

哈希函数.png

那么这个所谓的哈希函数是如何实现的呢？

在不同的语言中，哈希函数的实现方式是不一样的。这里以Java的常用集合HashMap为例，来看一看哈希函数在Java中的实现。

在Java及大多数面向对象的语言中，每一个对象都有属于自己的hashcode，这个hashcode是区分不同对象的标识。无论对象自身类型是什么，它们的hashcode都是一个整型变量。

既然都是整型变量，想要转换成数组的索引也就不难实现了。最简单的转换方式就是按照数组的长度进行取模。

通过哈希函数，我们可以把字符串或其他类型的键转换为数组的索引。

例如：给出一个长度为10的数组，当key=24321时，index=HashCode("24321") % Array.length。

哈希表的实现

1、写操作
写操作就是在哈希表中插入新的元素。分为两个步骤：

第一步：通过哈希函数，把key转化为数组的索引

第二步：如果当前key所对应的索引中没有元素，就把新元素添加进去。

注意：由于数组的长度是有限的，当插入的元素越来越多，我们很难保证每一个键通过哈希函数转换

为对应不同的索引，在这种情况下，我们不得不处理一个在哈希表中关键的问题，两个不同的键，通过哈希函数转换为同一个索引，这种情况称为哈希冲突，这也是哈希表中最复杂的。

解决方式：

• 开放寻址法

  开放寻址法很简单，当一个键通过哈希函数转换为索引并且这个索引已被占用时，我们可以“另谋高就”，寻找下一个空档的位置。

  例如，newKey通过哈希函数转换为索引2，该索引在数组中已经被占用了，那么就向后移动一位，看看索引为3的位置是否被占用了，如果占用了，那么继续向后移动一位，看看索引为4的位置是否被占用了，如果没有占用，就把key3存放到数组索引为4的索引。

  如图：

  开放寻址法1.png

  开放寻址法2.png

  开放寻址法3.png

  这就是开放寻址法的基本思路。当然，如果遇到哈希冲突时，寻址方式有很多种，在这里只是简单的举个例子。

• 链地址法

  链地址法说白就是一个链表的数组，数组当中每一个元素都是一个链表，当遇到哈希冲突时，只需要插入对应的链表即可。

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

}