JavaSE学习笔记 JDK1.7中HashMap底层实现原理
JDK1.7中HashMap源码底层实现原理
- 1.HashMap构造方法解析
- 2.HashMap中的put()过程
- 3.HashMap的get()方法
- 3.hash算法
- 4. HashMap性能问题
-
- 扩容机制
- 5.线程安全性问题
- 总结
- 附录
前面我们了解了Map集合的继承体系，Map集合具有常见的实现类：HashMap，LinkedHashMap以及TreeMap等。
-
Map集合的具体实现类的特点如下图所示：
本节我们主要深入去学习HashMap底层源码的解析。我们简单的知道JDK1.7中HashMap底层是由数组加链表实现的，JDK1.8中HashMap底层是由数组加链表加红黑树进行实现的。下面我们将走进源码，更深层的进行探索吧！
1.HashMap构造方法解析
首先我们了解写JDk1.7中HashMap构造方法的源码。
// 默认初始容量为16
static final int DEFAULT_INITIAL_CAPACITY = 16;
//默认负载因子为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//HashMap存放在底层的一维Entry数组
transient Entry[] table;
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
//定义扩容的临界值：扩容的临界值=默认初始容量*默认的负载因子=16*0.75=12
//即当数组中存放的元素为12时，此时会进行扩容的操作。
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
// 基础结构为Entry数组
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init()；
由此可以知道，当HashMap map=new HashMap()时，底层会创建默认初始容量为16的一维数组。基础结构为Entry数组，基本存储单元为Entry。
static class Entry<K,V> implements Map.Entry<K,V> {
final K key; //key值
V value; //value值
Entry<K,V> next; // 链表后置节点
final int hash;
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n; // 头插法: newEntry.next=e
key = k;
hash = h;
}
上面的Entry源码可以看出，Entry是链表结构。所以说：JDK1.7中HashMap的底层是由数组加链表进行实现的。
2.HashMap中的put()过程
HashMap的底层实现原理是什么？以JDK1.7为例进行说明
- 1.当我们进行HashMap map=new HashMap()时，在实例化之后，底层创建长度为16的一维数组 Entry [] table。
- 2.当我们map.put(key1，value1)时，可能已经执行多次的put操作。
- 3.首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经某种计算以后，得到在Entry数组存放位置。
- 4.判断该存放位置上是否数据为空：如果此位置上的数据为空，此时的key1-value1添加成功；如果此位置上的数据不为空，意味着此位置上存在一个或多个数据（以链表的形式存在）。
- 5.比较key1和已经存在的一个或者多个数据的哈希值：如果key1的哈希值与已经存在的数据的哈希值不相同，此时key1-value1添加成功；如果key1的哈希值和已经存在的某个数据的哈希值相同，则继续需要用equals()方法来比较内容。
- 6.调用key1所在类的equals()方法，比较：如果equals()返回false，此时的key1-value1添加成功；如果equals()返回的是true，使用value1替换相同key的value值。
鉴于很多小伙伴读完上面的文字内容，可能还是不是太了解，所以小编特将上述过程制作成如下的一张流程图，阅读起来可能更加方便。
注意：
关于上图列出的情况2与情况3：key1-value1和原来的数据以链表的形式进行存储的。
HashMap的put()方法源码：
public V put(K key, V value) {
// 如果table引用指向成员变量EMPTY_TABLE，那么初始化HashMap（设置容量、临界值，新的Entry数组引用）
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
// 若“key为null”，则将该键值对添加到table[0]处，遍历该链表，如果有key为null，则将value替换。没有就创建新Entry对象放在链表表头
// 所以table[0]的位置上，永远最多存储1个Entry对象，形成不了链表。key为null的Entry存在这里
if (key == null)
return putForNullKey(value);
// 若“key不为null”，则计算该key的哈希值
int hash = hash(key);
// 搜索指定hash值在对应table中的索引
int i = indexFor(hash, table.length);
// 循环遍历table数组上的Entry对象，判断该位置上key是否已存在
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))) {
// 如果这个key对应的键值对已经存在，就用新的value代替老的value
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 修改次数+1
modCount++;
// table数组中没有key对应的键值对，就将key-value添加到table[i]处
addEntry(hash, key, value, i);
return null;
}
-
可以看出，使用put()方法传递键与值时，HashMap会调用key所在类的hashCode()方法得到键的哈希值。计算出索引后用于找到bucket（哈希桶）的位置来存储Entry对象。
-
如果两个对象key的hash值相同，则它们在bucket的位置也相同，但equals()不相同，添加元素时会发生hash碰撞，也叫做hash冲突，HashMap使用链表来解决碰撞问题。
分析源码可知：使用put()方法在添加元素时，HashMap会遍历table数组，使用哈希值与equals()方法来判断数组中是否存在完全相同的key对象。如果这个key对象在table数组中已经存在，就用新的value值覆盖掉旧的value值。如果不存在，就创建一个新的Entry对象添加到table[i]处。
如果该table[i]已经存在其他元素，那么新的Entry对象将会存储在bucket链表的表头，通过next指向原有的Entry对象，形成链表结构（解决hash碰撞的方案）
Entry数据结构源码（HashMap内部类）：
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
/** 指向下一个元素的引用 */
Entry<K,V> next;
int hash;
/**
* 构造方法为Entry赋值
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
...
...
} ;
形成单链表的底层代码为：
/**
* 将Entry添加到数组bucketIndex位置对应的哈希桶中，并判断数组是否需要扩容
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
// 如果数组长度大于等于容量×负载因子，并且要添加的位置为null
if ((size >= threshold) && (null != table[bucketIndex])) {
// 长度扩大为原数组的两倍
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
/**
* 在链表中添加一个新的Entry对象在链表的表头
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
put方法的执行过程图：
3.HashMap的get()方法
如果两个不同的key的哈希值相同，两个值对象会存放在同一个bucket位置。要获取value，我们调用get()方法。HashMap会使用key的hashcode()方法获得哈希值，进而找到bucket位置。
因为HashMap在链表中存储的是Entry键值对，所以在找到bucket位置之后，会调用keyd的equlas()方法，按顺序进遍历链表的每一个Entry，直到找到想获取的Entry为止。如果恰好要搜索的Entry位该Entry链的最末端（该Entry是最早放入Entry中的），那么HashMap必须循环到最后才能找到该元素。
HashMap的get方法()源码：
public V get(Object key) {
// 若key为null，遍历table[0]处的链表（实际上要么没有元素，要么只有一个Entry对象），取出key为null的value
if (key == null)
return getForNullKey();
// 若key不为null，用key获取Entry对象
Entry<K,V> entry = getEntry(key);
// 若链表中找到的Entry不为null，返回该Entry中的value
return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
// 计算key的hash值
int hash = (key == null) ? 0 : hash(key);
// 计算key在数组中对应位置，遍历该位置的链表
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
// 若key完全相同，返回链表中对应的Entry对象
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
// 链表中没找到对应的key，返回null
return null;
}
3.hash算法
上面我们已经知道了在HashMap中要找到某个元素，是调用key所在类的hashCode()方法返回hash值，进而来求得对应数组中的位置。如何计算数组中索引的位置需要用的的就是hash算法。
HashMap的数据结构是数组和链表的结合，我们希望HashMap里面的元素位置尽量的分布均匀些，尽量使每个位置上的元素数量只有一个，那么当我们使用hash算法来计算这个位置时，马上就可以知道对应位置上的元素，而不需要我们再去遍历链表。
hash算法源码分析：
/**
* hash算法用来计算确定元素在数组中索引位置
* Returns index for hash code h.
*/
static int indexFor(int h, int length) {
// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
return h & (length-1);
4. HashMap性能问题
HashMap有两个参数影响其性能：初始容量与负载因子。均可以通过构造方法指定大小。
容量capacity是HashMap中bucket哈希桶中（Entry的链表）的数量，初始容量只是HashMap在创建时的容量，最大的设置初始容量为2^30，默认的初始容量为16（必须为2的幂）。
当数组的长度为2的n次幂时，不同的key通过indexFor()方法计算得到的数组位置相同的概率非常小，那么数据在数组上分布也比较均匀。即碰撞的几率小，当使用get()方法就不用遍历某个位置上的链表，这样查询的效率也就大大增加了。
负载因子loadFactor是HashMap在其容量自动增加之前可以达到多满的一种尺度，默认值为0.75。
扩容机制
当HashMap的长度超出默认容量（16）与加载因子（0.75）的乘积时，调用resize()方法重新创建一个原来HashMap大小2倍的newTable数组，最大扩容到2^30+1，并将原来的元素全部复制到newTable中。重新计算hash，然后再重新根据hash分配位置。这个过程称为rehash，因为调用hash方法重新找到新的bucket位置。
扩容机制源码分析：
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
// 如果之前的HashMap已经扩充打最大了，那么就将临界值threshold设置为最大的int值
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
// 根据新传入的newCapacity创建新Entry数组
Entry[] newTable = new Entry[newCapacity];
// 用来将原先table的元素全部移到newTable里面，重新计算hash，然后再重新根据hash分配位置
transfer(newTable, initHashSeedAsNeeded(newCapacity));
// 再将newTable赋值给table
table = newTable;
// 重新计算临界值，扩容公式在这儿（newCapacity * loadFactor）
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
5.线程安全性问题
HashMap是线程不安全的，在多线程情况下直接使用HashMap会出现一些安全性问题。
| 在多线程下使用HashMap的方案 |
|---|
| 1.在外部包装HashMap，实现同步机制 |
| 2.使用Map m = Collections.synchronizedMap(new HashMap(…));实现同步（官方参考方案，但不建议使用，使用迭代器遍历的时候修改映射结构容易出错） |
| 3.使用java.util.Hashtable，效率最低（现在基本已经被淘汰） |
| 4.使用java.util.concurrent.ConcurrentHashMap,相对安全，效率高（建议使用） |
总结
上面我们已经介绍了JDK1.7版本下HashMap底层实现原理。JDK1.8版本的HashMap源码实现与1.7是不一样的，有很大的不同。JDK1.8底层数据结构引入红黑树，而且JDK1.8HashMap的性能要高于JDK1.7，红黑树的引入将时间复杂度从O(n)将为O（logn）。
附录
参考博客：https://blog.csdn.net/ToBe_Coder/article/details/105065613
