由浅入深解析HashMap系列一---HashMap简单实现 增、删、查。

    如果让我们自己来设计HashMap,应该怎么做呢？数组。用数组存储节点，每个节点有key和value信息。那首先我们得要有节点存储key,value。

节点设计

在这个Node类中，有三个属性，hash值、key、value值。

class Node<K,V> {
        final int hash; //hash值
        final K key;//key
        V value;//value
//构造函数
        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final boolean equals(Object o) {
           if (o == this)
             return true;          
               if (Objects.equals(key, o.getKey()) &&
                   Objects.equals(value, o.getValue()))
                   return true;

            return false;
        }
}

注意：这里的构造函数中多了个next，大家忽略即可。奇怪，添加了这个代码块，怎么编辑的时候删除不了。哎。。。

初始化数组

定义一个容量为100的数组，用来存储node节点。 DEFAULT_INITIAL_CAPACITY ，它必须是必须是2的幂，在JDK提供的HashMap它的值为1 << 4，也就是16，这里直接填16不可以吗？为啥一定要这样写？

 static final int DEFAULT_INITIAL_CAPACITY=100;
 transient Node<K,V>[] table;
    /**
     * 构造函数
     */
    public SimpleHashMap()
  {
      table=(Node<K,V>[])new Node[DEFAULT_INITIAL_CAPACITY];
  }

增加操作-put

对一个容量为100的数组中添加元素其实很简单，具体步骤如下：

1）对key值进行hash，获取hash值。

2）通过上面获取的hash值、key、value值，创建node节点。

3）通过hash值和数组长度获取对应的下标。

4）对获取的下标赋值。

注意：这里对key进行hash调用的hash函数，具体我也不明白为啥要这样设计？

static final int hash(Object key) {
      int h;
      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

另外，根据hash值和容量（数组长度）获取对应的下标，具体我也不明白为啥要这样设计？

i = (n - 1) & hash

 具体的put代码如下：

 public V put(K key, V value)
    {
        //创建新节点
        Node<K,V> p; int n, i;
        //获取长度
        n=table.length;
        //对key值进行hash
        int hash=hash(key);
        //目前没有考虑hash冲突
        table[i = (n - 1) & hash]=newNode(hash,key,value);
        //返回原来的值
        return value;
        
    }
//创建新节点
 Node<K,V> newNode(int hash, K key, V value) {
      return new Node<>(hash, key, value);
  }

删除操作-remove

删除操作其实和添加差不多，首先要获取下标，然后再将下标的值赋值为null。

  public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key)) == null ?
            null : e.value;        
    }
    /**
     * 删除节点。
     * 目前不考虑冲突，当对应的下标有值且不为null时，返回该值，并将对应的值设置为Null
     * 这里考虑不太完善，因为hashmap是允许value为null的，这样并没有真正删除这个元素。
     * @param hash
     * @param key
     * @return
     */
    final Node<K,V> removeNode(int hash, Object key) {
        Node<K,V> p;int index;
        p=table[index = (table.length - 1) & hash];
        if(p!=null)
        {
            table[index]=null;
        }
        return p;
    }

查询操作-get

和remove、put操作一样，也是需要根据key值获取下标，然后再返回对应的value值。

 /**
     * 根据key值，获取value值
     * @param key
     * @return
     */
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
        
    }
    /**
     * 获取对应的值
     * @param hash
     * @param key
     * @return
     */
    final Node<K,V> getNode(int hash, Object key) {
       return  table[(table.length - 1) & hash];
    }

是否存在该元素--containskey

根据key值判断是否存在该元素，其实和get操作一样，只是这里返回的是布尔值。

 /**
     * 是否存在对于的key值
     * @param key
     * @return
     */
    public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
        
    }

哇！是不是很简单呢？这里有两个疑问，就是不知道那个下标的获取和hash值得获取为啥要那样设计？是因为这样是最优的吗？下标的获取这种方法，发生冲突的几率就少很多吗？在整个系列中，我并没有讨论HashMap继承AbstractMap，实现Map接口。