HashMap的底层学习

HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

　　值得注意的是HashMap不是线程安全的，如果想要线程安全的HashMap，可以通过Collections类的静态方法synchronizedMap获得线程安全的HashMap。

HashMap的数据结构

　　HashMap的底层主要是基于数组和链表来实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置。HashMap中主要是通过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就一样。如果存储的对象对多了，就有可能不同的对象所算出来的hash值是相同的，这就出现了所谓的hash冲突。学过数据结构的同学都知道，解决hash冲突的方法有很多，HashMap底层是通过链表来解决hash冲突的。

图中，0~15部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。

从上图我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点Bucket桶。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表

HashMap其实也是一个线性的数组实现的,所以可以理解为其存储数据的容器就是一个线性数组。

首先HashMap里面实现一个静态内部类Entry，其重要的属性有 key , value, next，从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean，我们上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[]，Map里面的内容都保存在Entry[]里面。

HashMap的Entry类代码/** Entry是单向链表。         * 它是 “HashMap链式存储法”对应的链表。         *它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数      **/      static class Entry<K,V> implements Map.Entry<K,V> {            final K key;            V value;            // 指向下一个节点            Entry<K,V> next;            final int hash;            // 构造函数。            // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"            Entry(int h, K k, V v, Entry<K,V> n) {                value = v;                next = n;                key = k;                hash = h;            }            public final K getKey() {                return key;            }            public final V getValue() {                return value;            }            public final V setValue(V newValue) {                V oldValue = value;                value = newValue;                return oldValue;            }            // 判断两个Entry是否相等            // 若两个Entry的“key”和“value”都相等，则返回true。            // 否则，返回false            public final boolean equals(Object o) {                if (!(o instanceof Map.Entry))                    return false;                Map.Entry e = (Map.Entry)o;                Object k1 = getKey();                Object k2 = e.getKey();                if (k1 == k2 || (k1 != null && k1.equals(k2))) {                    Object v1 = getValue();                    Object v2 = e.getValue();                    if (v1 == v2 || (v1 != null && v1.equals(v2)))                        return true;                }                return false;            }            // 实现hashCode()            public final int hashCode() {                return (key==null   ? 0 : key.hashCode()) ^                       (value==null ? 0 : value.hashCode());            }            public final String toString() {                return getKey() + "=" + getValue();            }            // 当向HashMap中添加元素时，绘调用recordAccess()。            // 这里不做任何处理            void recordAccess(HashMap<K,V> m) {            }            // 当从HashMap中删除元素时，绘调用recordRemoval()。            // 这里不做任何处理            void recordRemoval(HashMap<K,V> m) {            }    }

HashMap其实就是一个Entry数组，Entry对象中包含了键和值，其中next也是一个Entry对象，它就是用来处理hash冲突的，形成一个链表。

HashMap的关键属性

         transient Entry[] table;//存储元素的实体数组

        transientint size;//存放元素的个数

         int threshold; //临界值   当实际大小超过临界值时，会进行扩容threshold = 加载因子          *容量

         final float loadFactor; //加载因子

        transientint modCount;//被修改的次数

 

其中loadFactor加载因子是表示Hsah表中元素的填满的程度.

若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但:冲突的机会加大了.链表长度会越来越长,查找效率降低。

       反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了.表中的数据将过于稀疏（很多空间还没用，就开始扩容了）

HashMap的存取public V put(K key, V value) {    // HashMap允许存放null键和null值。    // 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。    if (key == null)        return putForNullKey(value);    // 根据key的hashCode重新计算hash值。    int hash = hash(key.hashCode());    // 搜索指定hash值所对应table中的索引。    int i = indexFor(hash, table.length);    // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。    for (Entry<K,V> e = table[i]; e != null; e = e.next) {        Object k;        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {            V oldValue = e.value;            e.value = value;            e.recordAccess(this);            return oldValue;        }    }    // 如果i索引处的Entry为null，表明此处还没有Entry。    // modCount记录HashMap中修改结构的次数    modCount++;    // 将key、value添加到i索引处。    addEntry(hash, key, value, i);    return null;}

当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。

 

HashMap的取数据

       get(key)方法时获取key的hash值，计算hash&(n-1)得到在链表数组中的位置first=tab[hash&(n-1)],先判断first的key是否与参数key相等，不等就遍历后面的链表找到相同的key值返回对应的Value值即可

 

那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为 2*16=32

    在jdk7中，HashMap处理“碰撞”的时候，都是采用链表来存储，当碰撞的结点很多时，查询时间是O（n）。
       在jdk8中，HashMap处理“碰撞”增加了红黑树这种数据结构，当碰撞结点较少时，采用链表存储，当较大时（>8个），采用红黑树（特点是查询时间是O（logn））存储（有一个阀值控制，大于阀值(8个)，将链表存储转换成红黑树存储）。