9.5-全栈Java笔记:Map接口中的实现类HashMap

上节聊到「Map接口和实现类」，今天我们深入探讨其实现类中的HashMap如何进行底层实现。

Hashmap基本结构讲解

哈希表的基本结构就是“数组+链表”。我们打开HashMap源码，发现有如下两个核心内容：

public class   HashMap<K,V>

    extends   AbstractMap<K,V>

    implements   Map<K,V>, Cloneable, Serializable {

 

    /**

     * The default initial capacity -   MUST be a power of two.

       * 核心数组默认初始化的大小为16（数组大小必须为2的整数幂）

     */

    static final int DEFAULT_INITIAL_CAPACITY =   16;

 

    /**

     * The load factor used when none   specified in constructor.

     *  负载因子（核心数组被占用超过0.75，则开始启动扩容）

     */

    static final float DEFAULT_LOAD_FACTOR =   0.75f;

 

    /**

     * The table, resized as necessary.   Length MUST Always be a power of two.     核心数组（根据需要可以扩容）。数组长度必须始终为2的整数幂。

     */

    transient   Entry[] table;

 

    /**

     * The number of key-value   mappings contained in this map.

     *    存储的键值对的数量

     */

    transient int size;

 

    /**

     * The next size value at which to resize   (capacity * load factor).

     *  扩容后新数组的大小????  

     */

    int threshold;

其中的，Entry[] table 就是HashMap的核心数组结构，我们也称之为“位桶数组”。我们再继续看Entry是什么，源码如下：

    static class Entry<K,V> implements   Map.Entry<K,V> {

        final K key;

        V value;

        Entry<K,V> next;

        final int hash;

 

        /**

         * Creates new entry.

         */

        Entry(int h,   K k, V v, Entry<K,V>   n) {

            value =   v;

            next =   n;

            key =   k;

            hash =   h;

        }

    //其余代码省略

}

一个Entry对象存储了：

key：键对象              

value：值对象

next:下一个节点

hash: 键对象的hash值 

显然就是一个单向链表结构，我们使用图形表示一个Entry的典型示意：

然后，我们画出Entry[]数组的结构（这也是HashMap的结构）：

存储数据过程put(key,value)

明白了HashMap的基本结构后，我们继续深入学习HashMap如何存储数据。此处的核心是如何产生hash值，该值用来对应数组的存储位置。

我们的目的是将”key-value两个对象”成对存放到HashMap的Entry[]数组中。

第一步：获得key对象的hashcode

首先调用key对象的hashcode()方法，获得hashcode。

第二步：根据hashcode计算出hash值(要求在[0, 数组长度-1]区间)

hashcode是一个整数，我们需要将它转化成范围在[0, 数组长度-1]的范围。我们要求转化后的hash值尽量均匀的分布在[0,数组长度-1]这个区间，减少“hash冲突”。 

一种极端简单和低下的算法是：

hash值 = hashcode/hashcode;  

也就是说，hash值总是1。意味着，键值对对象都会存储到数组索引1位置，这样就形成一个非常长的链表。相当于每存储一个对象都会发生“hash冲突”，HashMap也退化成了一个“链表”。

一种简单和常用的算法是（相除取余算法）：

ash值 =  hashcode%数组长度

这种算法可以让hash值均匀的分布在[0,数组长度-1]的区间。 早期的HashTable就是采用这种算法。但是，这种算法由于使用了“除法”，效率低下。JDK后来改进了算法。

首先约定数组长度必须为2的整数幂，这样采用位运算即可实现取余的效果：

hash值 = hashcode&(数组长度-1)

如下为我们自己测试简单的hash算法：

public class   Test {

    public static void   main(String[] args) {

       int h   = 25860399;

       int   length = 16;     //length为2的整数次幂,则h&(length-1)就相当于对length取模

       myHash(h, length);

    }

   

   

    /**

     *

     * @param   h  任意整数

     * @param   length  长度必须为2的整数幂

     * @return

     */

    public static  int   myHash(int h,int   length){

       System.out.println(h&(length-1));

    //length为2的整数幂情况下，和取余的值一样

       System.out.println(h%length);      //取余数

      

       return   h&(length-1);

    }

}

运行如上程序，我们就能发现直接取余(h%length)和位运算(h&(length-1))结果是一致的。

事实上，为了获得更好的散列效果，JDK对hashcode进行了两次散列处理（核心目标就是为了分布更散更均匀），源码如下：

static int   hash(int h) {

    // This function ensures   that hashCodes that differ only by

    // constant multiples at   each bit position have a bounded

    // number of collisions   (approximately 8 at default load factor).

    h ^= (h >>> 20) ^ (h >>>   12);

    return h   ^ (h >>> 7) ^ (h >>> 4);

}

 

static int   indexFor(int h, int   length) {

    return h   & (length-1);

}

第三步：生成Entry对象

一个Entry对象包含4部分：key对象、value对象、hash值、下一个Entry对象。我们现在算出了hash值。下一个Entry对象为null等。

第四步：将Entry对象放到table数组中

如果本Entry对象对应的数组索引位置还没有放Entry对象，则直接将Entry对象存储进数组。

如果对应索引位置已经有Entry对象，则将已有Entry对象的next指向本Entry对象，形成链表。

 

总结如上过程：

当添加一个元素（key-value）时，首先计算key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，就形成了链表，同一个链表上的Hash值是相同的，所以说数组存放的是链表。 JDK8中，当链表长度大于8时，链表就转换为红黑树，这样又大大提高了查找的效率。

取数据过程get(key)

我们需要通过key对象获得“键值对”对象，进而返回value对象。明白了存储数据过程，取数据就比较简单了。

第一步：获得key的hashcode，通过hash()散列算法得到hash值，进而定位到数组的位置。

第二步：在链表上挨个比较key对象。 调用equals()方法，将key对象和链表上所有节点的key对象进行比较，直到碰到返回true的节点对象为止。

第三步：返回equals()为true的节点对象的value对象。

 

明白了存取数据的过程，我们再来看一下hashcode()和equals方法的关系：

  Java中规定，两个内容相同(equals()为true)的对象必须具有相等的 hashCode

如果equals()为true，两个对象的hashcode不同；那在整个存储过程中就发生了悖论。 

扩容问题

HashMap的位桶数组，初始大小为16。实际使用时，显然大小是可变。如果位桶数组中的元素达到（0.75*数组 length）， 就重新调整数组大小变为原来2倍大小。

扩容很耗时。扩容本质就是定义新的更大的数组，并将旧数组内容挨个拷贝到新数组中。

JDK8将链表在大于8情况下变为红黑二叉树

JDK8中，HashMap在存储一个元素时，当对应链表长度大于8时，链表就转换为红黑树，这样又大大提高了查找的效率。

下一节，我们简单介绍一个二叉树。同时，也便于大家理解TreeMap的底层结构。

 

---

「全栈Java笔记」是一部能帮大家从零到一成长为全栈Java工程师系列笔记。笔者江湖人称 Mr. G，10年Java研发经验，曾在神州数码、航天院某所研发中心从事软件设计及研发工作，从小白逐渐做到工程师、高级工程师、架构师。精通Java平台软件开发，精通JAVAEE，熟悉各种流行开发框架。

  笔记包含从浅入深的六大部分：

  A-Java入门阶段

  B-数据库从入门到精通

  C-手刃移动前端和Web前端

  D-J2EE从了解到实战

  E-Java高级框架精解

  F-Linux和Hadoop