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

Posted 2020-09-26

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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情况下变为红黑二叉树