Java中HashMap的实现原理分析

JAVA中基本存储结构

java中基本数据存储结构分为数组和链表，各有各特点，不过都比较极端

数组

数组的存储是连续的，占用空间大，如果数组较大，而剩余的空间不够存储的话，剩余的存储空间就会浪费，占用内存严重，空间复杂度大，优点是查询速度快，但插入删除慢

链表

链表占用空间不连续，比较分散，占用内存比较宽松，空间复杂度较小，时间复杂度较大，查找比较困难，插入删除快。

哈希表

哈希表结合了数组和链表两者特点，占空间又比较小，查询时间快，可以理解为链表的数组，结构类似如下

hashCode

1、对于hashCode，hashCode是用于在散列解构存储中寻找对象地址的，由hash算法获得，具体不在此讨论hash算法，需要了解点击此处，哈希算法详解

2、对于两个相同的对象，那么他们的hashCode一定是一样的，但hashCode一样不一定对象就相同，HashCode相同，仅仅是认为这两个对象存储在相同的位置，如果要判断这两个对象相同，需要判断equals方法，如果equals也相同，对象类型相同，才可以判断这两个对象相同。

3、如果对象的equals被重写，那么hashCode也要被重写，否则只能判断是对象的值相等。

4、hashCode是用于寻址的，即定位，而equals是比较对象的值的。

HashMap的put方法

put方法先通过给定的key值，通过hash算法获得hash值hashCode，然后除以哈希表的数组大小size，获得余数，即hashCode%size，获得的这个余数就是存储这个key/value所在数组的地址，如果这个位置已经有值，然后判断hashCode是否相等

        hashCode相等：判读key是否相同，key相同，新的value值覆盖旧的值，key不相同，新添加进来的与原来的形成链表，并且新的数据放在最前面。

hashCode不相等：新添加进来的与原来的形成链表，并且新的数据放在最前面。

通过以上方法可以高效的解决hashMap冲突问题。

HashMap的get方法

JDK1.8源码如下：

 /**
     * Returns the value to which the specified key is mapped,
     * or {@code null} if this map contains no mapping for the key.
     *
     * <p>More formally, if this map contains a mapping from a key
     * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
     * key.equals(k))}, then this method returns {@code v}; otherwise
     * it returns {@code null}.  (There can be at most one such mapping.)
     *
     * <p>A return value of {@code null} does not <i>necessarily</i>
     * indicate that the map contains no mapping for the key; it's also
     * possible that the map explicitly maps the key to {@code null}.
     * The {@link #containsKey containsKey} operation may be used to
     * distinguish these two cases.
     *
     * @see #put(Object, Object)
     */
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    /**
     * Implements Map.get and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

从HashMap中get元素时，首先计算key的hashCode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。

HashMap的resize

HashMap默认数组大小是16，当超过这个16*loadFactor（loadFactor默认0.75）时就会成倍的扩容，然后之前计算好已经存储到指定位置的数据又要重新根据数组大小划分然后存储。这是非常消耗性能的。这就是resize，所有为了避免这种情况的发生，如果知道要用的HashMap的个数时，定义的时候指定个数，如知道个数为18个，按照loadFactor系数，应该为18/0.75=24，需要定义16的倍数，所以应该定义为32.

总结

根据以上分析，HashMap的实现原理总结如下：

1. 利用key的hashCode重新hash计算出当前对象的元素在数组中的下标
2. 存储时，如果出现hash值相同的key，此时有两种情况。(1)如果key相同，则覆盖原始值；(2)如果key不同（出现冲突），则将当前的key-value放入链表中
3. 获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。
4. 理解了以上过程就不难明白HashMap是如何解决hash冲突的问题，核心就是使用了数组的存储方式，然后将冲突的key的对象放入链表中，一旦发现冲突就在链表中做进一步的对比。

参考博文：

http://www.cnblogs.com/yuanblog/p/4441017.html