模拟实现HashMap

为了方便实现，突出重点，将key指定为String类型，将Value指定位Integer类。在实际中，如果Key的类型为自己的实现类，那么必须重写该类的hashCode()和equals()两个方法，重写hashCode()方法是因为在找key对应的下标时需要调用hashCode()方法，重写equals()方法是因为两个相同对象的哈希值必须相同，程序怎么知道哪两个对象相同，就是通过equals方法。
对于还不了解哈希表的同学建议先去看上一篇博客哈希表（HashTable），哈希冲突的避免、解决
。
下面开始进入正题，对于HashMap的实现最重要的两个问题在我看来是：

1. 拿到一个key时能获取在顺序结构中合理的下标
2. 当该哈希表的负载因子大于阈值时需要对哈希表进行扩容

下面先来讨论怎么解决第一个问题：
要获取下标，肯定是先得到key的哈希值hash，然后让hashCode & ( array.length - 1 )，而且规定数组的长度必须是2的n次方，为什么呢？
拿长度为16举例：
16的二进制为0b10000 减 1 就是0b1111在和hashCode 做 与运算 不管hash有多少位，大于4位的 & 之后都为0，最后只剩下四位，恰好这个数值大于等于0小于16,可以作为下标。
这样的到的下标还有一个新的问题，因为key得到的hash值是均匀分布的一长串数字，现在我们忽略前四位以后的数字，这样计算出来的下标还不够均匀，解决方法是充分利用得到hash值让最后计算出来的下标相对更佳合理，我们在让 hashCode & ( array.length - 1 ) 之前先让hash = hashCode ^ (hashCode >> 16) 即让得到的哈希值的低16位和高16位做异或运算，最终再让index = hash & ( array.length - 1 )，这样两步操作下来可以的到相对合理的下标。这个方法也是Java中HashMap所用的。
接着来讨论第二个问题：

哈希表的负载因子是哈希表装满程度的标志因子。由于表长是定值，负载因子和“填入表中的元素个数”成正比，所以负载因子越大，表明填入表中的元素越多，产生冲突的可能性就越大；反之，负载因子越小，表明填入表中的元素越少，长生冲突的可能性就越小。
对于开放定址法，负载因子是特别重要的因素，应严格限制在0.7 - 0.8以下。Java中将负载因子限制在0.75.超过此值将resize哈希表，即对底层顺序结构扩容然后将旧表中的数据重新一一放入到新表中。

所以我们需要设置一个阈值为0.75，在每次插入之后计算 负载因子 = size / array.length 看看是否超过阈值，如果大于阈值了，就使用 resize()方法进行扩容，具体做法是创建一个长度为当前数组长度二倍的数组，然后遍历当前数组所有键值对，遍历的过程中将这些键值对放到新的数组中。

下面是实现代码：

//节点类
public class Node {
    public String key;
    public Integer val;
    public Node next;

    public Node(){
        key = null;
        val = null;
    }
    public Node(String key, Integer val){
        this.val = val;
        this.key = key;
    }

}

//MyHashMap类
public class MyHashMap {
    private Node[] array;
    private int size;

    private final double LOAD_FACTOR = 0.75;
    public MyHashMap(){
        array = new Node[16];
        size = 0;
    }

    private int indexOf(String key){
        /*
            array.length必须为2的n次方，用哈希值&array.length - 1,

        */
        int hashCode = key.hashCode();
        int hash = hashCode ^ (hashCode >> 16);
        //&出来的结果一定大于零小于array.length
        return hash & (array.length - 1);
    }

    private int newIndexOf(String key){
        int hashCode = key.hashCode();
        int hash = hashCode ^ (hashCode >> 16);
        return hash & (array.length * 2 - 1);
    }

    public Integer get(String key){
        Node cur = array[indexOf(key)];
        while (cur != null){
            if (cur.key.equals(key)){
                return cur.val;
            }
            cur = cur.next;
        }
        return null;
    }

    public Integer put(String key, Integer value){
        int index = indexOf(key);
        Node cur = array[index];
        while (cur != null){
            if (cur.key.equals(key)){
                Integer oldVal = cur.val;
                cur.val = value;
                return oldVal;
            }
            cur = cur.next;
        }
        Node node = new Node(key, value);
        node.next = array[index];
        array[index] = node;
        size++;

        if ((double)size / array.length > LOAD_FACTOR){
            resize();
        }
        return value;
    }

    private void resize() {
        Node[] newArray = new Node[array.length * 2];
        for (Node head : array){
            Node cur = head;
            while (cur != null){
                int index = newIndexOf(cur.key);
                Node next = cur.next;
                cur.next = newArray[index];
                newArray[index] = cur;
                cur = next;
            }
        }
        array = newArray;
    }

    public Integer remove(String key){
        int index = indexOf(key);
        Node cur = array[index];
        Node prev = null;
        while (cur != null){
            if (cur.key.equals(key)){
                if (prev == null){
                    array[index] = cur.next;
                }else {
                    prev.next = cur.next;
                }
                size--;
                return cur.val;
            }
            prev = cur;
            cur = cur.next;
        }
        return null;
    }
}