自定义哈希表实现

哈希表概念

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。
简单来说，解决存储空间的考虑。试想，将100个关键字存入大小为100的数组里，此时肯定是不需要哈希函数的，一对一的放，肯定是可以实现的。但是当数据量增大，将1000个关键字，存入大小为100的数组里呢？此时一个一个的放，那剩下的怎么办呢，所以，我们需要某种计算方法，既能把这1000个关键字存进去，而且最主要是还能取出来。这就是哈希函数要做的事情，给每一个关键字找一个合适的位置，让你既能存进去，又能取出来。注意，哈希表里面一般存放的是字典数据类型，即（key，value）的数据，是根据key 去存取value。

哈希碰撞

哈希表的设计最主要就是解决哈希碰撞，当存储一个数据，该数据的哈希值已经在数组中存在，此时就会产生哈希碰撞，而解决哈希碰撞的方式有很多，例如链地址法，开放地址法，再哈希，这里，我们用链地址法解决哈希碰撞，通常的做法就是使用链表，当出现碰撞时，将该数据存储在链表中，这样，就可以根据hash值以及在链表中的位置查找元素，但当哈希碰撞增多时，如在索引1的位置中链表有很多个元素，这样对后续元素的查找效率会降低，此时我们可以将链表改造成红黑树，红黑树的时间复杂度要比链表高，其效率就会更高。

链地址法

哈希冲突后，用链表去延展来解决。

这个图中h(x) = x mod 10 ;是一个哈希函数，可见代入x=91和x=1的时候都会到映射到键值为1的slot，那么这样就会引发冲突，在链地址法中，用链表延展去存储同键值的数据。
优点：

链地址法处理冲突简单，且无堆积现象，即非同义词决不会发生冲突，因此平均查找长度较短；
在用链地址法构造的散列表中，删除结点的操作易于实现

代码实现

package HashTable;

import java.util.Map;
import java.util.TreeMap;

public class HashTable<K, V> {

    private static final int upperTol = 10;//哈希冲突向上阀值
    private static final int lowerTol = 2;//哈希冲突向下阀值
    private static final int initCapacity = 7;//初始数组容量

    private TreeMap<K, V>[] hashtable;
    private int size;
    private int M;

    public HashTable(int M) {
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];
        for (int i = 0; i < M; i++)
            hashtable[i] = new TreeMap<>();
    }


    public HashTable() {
        this(initCapacity);
    }

    //设置哈希值
    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 >= upperTol * M)

                resize(2 * M);
        }
    }

    //删除元素
    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 <= lowerTol * M && M > initCapacity)
                resize(M / 2);
        }
        return ret;
    }

    //修改value
    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);
    }

    //数组大小调整
    private void resize(int newM) {
        TreeMap<K, V>[] newHashTable = new TreeMap[newM];
        for (int i = 0; i < newM; i++)
            newHashTable[i] = new TreeMap<>();

        for (int i = 0; i < M; i++)
            for (K key : hashtable[i].keySet())
                newHashTable[hash(key)].put(key, hashtable[i].get(key));

        this.M = newM;
        this.hashtable = newHashTable;
    }
}