HashMap源码窥探
前言
人们对于任何事物的认知,往往都存在这么一个现象:只有你了解的东西,你才会感兴趣。
HashMap之于Java开发者来说,也是如此。相信多数人在起初相当长的时间内,对HashMap的印象都是“Map接口的实现类,是基于哈希的,用于存放键-值对,允许null作为键和值,非线程安全的”,仅此而已。
于是在程序编写过程中便“肆无忌惮”往里放键-值对。而只有你对HashMap的实现有了一定的了解之后,你才会有兴趣研究HashMap深层次的问题,比如“HashMap最多能放多少个键-值对?如何提高HashMap的使用效率?”。其实,我一直都对HashMap的“线性数组+链表”的实现机制充满好奇,刚刚有时间研究了一下源码,现把心得与大家分享。
HashMap的数据结构
/**
* 初始容量,大小必须是2的指数次方,默认是16.
*/
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
* 默认最大容量,值为1<<30
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 哈希表的默认加载因子,值为0.75.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 存储元素的数组,大小必须是2的指数次方,默认是16.
*/
transient Entry[] table;
/**
* THashMap中的存储的<K,V>映射的数目.
*/
transient int size;
/**
* threshold=容量*加载因子。当实际数目大于threshold时,HashMap就需要扩容.
* @serial
*/
int threshold;
/**
* 哈希表的加载因子,如果创建时不指定loadFactor,则使用DEFAULT_LOAD_FACTOR.
*
* @serial
*/
final float loadFactor;
//... ...
/**
*
* <p>用一个静态内部类来定义数组项链表的元素</p>
*
* @author bruce.yang
* @version 1.0 Created on 2014-10-22 上午11:39:50
*/
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;
}
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;
}
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;
}
public final int hashCode() {
return (key==null ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}
public final String toString() {
return getKey() + "=" + getValue();
}
可以看出,HashMap正是采用数组(table)类存储数据的,而数组每一个元素则是一个被静态内部类Entry封装起来的对象,元素在数组中的下标则是根据key的hashcode计算出来的;当元素下标重复的时候,会在此下标处形成一个链表,而这个链表就是通过Entry结构来实现的。我们看到,这个Entry结构是一个单向链表,它只有一个next项指向下一个元素,此外,它还包含<K,V>对,同时还有一个哈希值hash。
HashMap的put方法
当我们往hashmap中put元素的时候,先是根据key的hash值计算得出这个元素在数组中的位置(即下标),然后就可以把这个元素放到对应的位置中了。如果这个位子上已经存放有其他元素了,那么在同一个位子上的元素将以链表的形式存放,新加入的放在链头,最先加入的放在链尾。源码:
/**
* 建立指定key和value之间的映射:
* 如果已经存在key,则替换对应的value,并返回原来的value;如果原来没有建立映射,则建立映射,并返回null。
* 当然了,由于HashMap允许key和value为null,返回null还有可能就是原来的value为null。
*/
public V put(K key, V value) {
//如果key==null,则调用专门的方法处理
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
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;
}
}
modCount++;
//加入新的项
addEntry(hash, key, value, i);
//原来不存在这项
return null;
}
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
/**
* 添加key-value项
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
//加入该项到链表头部
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}
/**
*扩充HashMap的容量
*/
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}
/**
* 将原来数组中元素传输到新数组中
*/
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
Entry<K,V> e = src[j];
if (e != null) {
src[j] = null;
do {
Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
}
}
}
可以看到,首先判断key是否为null:
1).若为null,则调用专门的方法putForNullKey(value)处理并返回。
1.1)如果事先已经存在key为null的映射,则替换后返回old value。
1.2)如果不存在,则添加新的项到链表中
2).若key不为null
2.1)首先计算key的哈希值,然后根据哈希值和table数组的长度定位数组项。
2.2)对数组项的链表进行遍历,如果key的哈希值与链表中的某一项的哈希值相等且key本身引用值相等或者引用值所指向的对象相等,则替换相应项的value值为新的value,并返回老的value。如果没有找到相同的key,则加入该项到链表中。
2.3)addEntry方法直接将新的项加入到链表的头部,新项的next引用指向原来的链表项。此外判断是否需要扩容,如果此时存储的项数目size大于等于threshold,则扩大HashMap容量为原来的2倍。
2.4)resize方法用来扩容HashMap。默认是扩容至原来的2倍大小。
HashMap的get方法
当从hashmap中get元素时,首先计算key的hashcode,找到数组中对应位置的某一元素,然后通过key的equals方法在对应位置的链表中找到需要的元素。源码:
/**
* 根据key取得value
*/
public V get(Object key) {
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
return null;
}
private V getForNullKey() {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
可以看到,如果key为null,get方法与put方法对应,对null值也有特殊处理,即直接到table[0]中去找key为null对应的value。如果key不为null,则定位key所在数组项,然后遍历链表,如果存在key,则返回对应的value值,否则返回null。
HashMap的初始化
/**
*指定初始化容量和加载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
//initialCapacity不能小于0
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//如果指定容量大于默认最大容量,则按照默认最大容量创建
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//loadFactor不能小于0
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//找最大于指定初始化容量的2的指数幂作为表的真实容量
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}
/**
*只指定初始化容量,加载因子采用默认
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 初始化容量和加载因子都采用默认
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}
只看源码和注释就一目了然了,这里所要特别注意一下带两个参数的构造方法,其初始化时的初始大小不一定是你所指定的大小。
HashMap的containsKey方法
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
主要是通过getEntry方法实现,先计算key的hash值,然后在table数组中查找hash值所对应的链表元素,然后遍历链表,判断链表中Entry的key是否和方法参数中的key值equals相等
如果相等即返回,至此可得知存在key值的元素。
HashMap的putAll方法
public void putAll(Map<? extends K, ? extends V> m) {
int numKeysToBeAdded = m.size();
if (numKeysToBeAdded == 0)
return;
if (table == EMPTY_TABLE) {
inflateTable((int) Math.max(numKeysToBeAdded * loadFactor, threshold));
}
/*
* Expand the map if the map if the number of mappings to be added
* is greater than or equal to threshold. This is conservative; the
* obvious condition is (m.size() + size) >= threshold, but this
* condition could result in a map with twice the appropriate capacity,
* if the keys to be added overlap with the keys already in this map.
* By using the conservative calculation, we subject ourself
* to at most one extra resize.
*/
if (numKeysToBeAdded > threshold) {
int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
if (targetCapacity > MAXIMUM_CAPACITY)
targetCapacity = MAXIMUM_CAPACITY;
int newCapacity = table.length;
while (newCapacity < targetCapacity)
newCapacity <<= 1;
if (newCapacity > table.length)
resize(newCapacity);
}
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
put(e.getKey(), e.getValue());
}
- 首先是判断参数map是否是空map,如果是直接返回。
- 然后通过判断初始化一下table的长度,设置加载因子。
- 遍历调用put方法把map数据放入。
HashMap的remove方法
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
Entry<K,V> prev = table[i];
Entry<K,V> e = prev;
while (e != null) {
Entry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
- 开始也是一样的查询是否有当前要删除的元素。
- 然后把链表的第一个元素当作前一个元素。
- 最后遍历链表判断是否是要删除的元素,调整前后元素的关联关系。如果要删除的元素是链表第一个元素的话,就把数组索引的元素指向下一个元素,反之,就把前一个元素的next元素置成next的元素。
最后、文章开头所提出的问题也不在是问题了
1).HashMap最大容量是1 << 30,
2).而影响HashMap性能的两个因素是:初始容量和加载因子。这里借用书中的一段话来表述:容量是哈希表中桶的数量,初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时,则要对该哈希表进行 rehash 操作(即重建内部数据结构),从而哈希表将具有大约两倍的桶数。
通常,默认加载因子 (0.75)在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销,但同时也增加了查询成本(在大多数 HashMap类的操作中,包括 get 和 put操作,都反映了这一点)。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子,以便最大限度地减少 rehash操作次数。如果初始容量大于最大条目数除以加载因子,则不会发生 rehash操作。
读到这里,相信你对HashMap已经有了一个更深刻的认识。
HashMap源码窥探的更多相关文章
- HashMap 源码解析
HashMap简介: HashMap在日常的开发中应用的非常之广泛,它是基于Hash表,实现了Map接口,以键值对(key-value)形式进行数据存储,HashMap在数据结构上使用的是数组+链表. ...
- HashMap源码分析
最近一直特别忙,好不容易闲下来了.准备把HashMap的知识总结一下,很久以前看过HashMap源码.一直想把集合类的知识都总结一下,加深自己的基础.我觉的java的集合类特别重要,能够深刻理解和应用 ...
- JAVA源码分析-HashMap源码分析(一)
一直以来,HashMap就是Java面试过程中的常客,不管是刚毕业的,还是工作了好多年的同学,在Java面试过程中,经常会被问到HashMap相关的一些问题,而且每次面试都被问到一些自己平时没有注意的 ...
- Java集合---HashMap源码剖析
一.HashMap概述二.HashMap的数据结构三.HashMap源码分析 1.关键属性 2.构造方法 3.存储数据 4.调整大小 5.数据读取 ...
- 【转】Java HashMap 源码解析(好文章)
.fluid-width-video-wrapper { width: 100%; position: relative; padding: 0; } .fluid-width-video-wra ...
- 【JAVA集合】HashMap源码分析(转载)
原文出处:http://www.cnblogs.com/chenpi/p/5280304.html 以下内容基于jdk1.7.0_79源码: 什么是HashMap 基于哈希表的一个Map接口实现,存储 ...
- HashMap源码解读(转)
http://www.360doc.com/content/10/1214/22/573136_78188909.shtml 最近朋友推荐的一个很好的工作,又是面了2轮没通过,已经是好几次朋友内推没过 ...
- HashMap源码剖析
HashMap源码剖析 无论是在平时的练习还是项目当中,HashMap用的是非常的广,真可谓无处不在.平时用的时候只知道HashMap是用来存储键值对的,却不知道它的底层是如何实现的. 一.HashM ...
- Java中HashMap源码分析
一.HashMap概述 HashMap基于哈希表的Map接口的实现.此实现提供所有可选的映射操作,并允许使用null值和null键.(除了不同步和允许使用null之外,HashMap类与Hashtab ...
- 转:【Java集合源码剖析】HashMap源码剖析
转载请注明出处:http://blog.csdn.net/ns_code/article/details/36034955 您好,我正在参加CSDN博文大赛,如果您喜欢我的文章,希望您能帮我投一票 ...
随机推荐
- [转贴]手把手教你 GitLab 的安装及使用
https://www.jianshu.com/p/b04356e014fa 前言 新入职公司,发现公司还在使用落后生产工具 svn,由于重度使用过 svn 和 git ,知道这两个工具之间的差异,已 ...
- vue 路由守卫是否携带token
//整个实例出来 配置路由守卫 const router = new Router({ //这里面是路由配置哈 }) router.beforeEach((to, from, next) => ...
- vue混入mixin
<div id="app"> --{{nick11}} </div> <script> // 全局混入 不需要注册 var m1 = Vue.m ...
- el-dialog组件无法跟新视图上的数据
<el-dialog title="提示" :visible.sync="dialogVisible" width="30%"> ...
- 【JS 逆向百例】网洛者反爬练习平台第二题:JJEncode 加密
关注微信公众号:K哥爬虫,持续分享爬虫进阶.JS/安卓逆向等技术干货! 声明 本文章中所有内容仅供学习交流,抓包内容.敏感网址.数据接口均已做脱敏处理,严禁用于商业用途和非法用途,否则由此产生的一切后 ...
- c和c++开发工具之clion和vs
个人体验结果 如果是CMake或者要跨平台的话,建议使用CLion 像我在看书写练习题的话,Clion使用cmake编译c/c++源码更简单上手使用. 如果项目不大,两者都可以.如果关联子项目或第三方 ...
- 深入浅出Java多线程(二):Java多线程类和接口
引言 大家好,我是你们的老伙计秀才!今天带来的是[深入浅出Java多线程]系列的第二篇内容:Java多线程类和接口.大家觉得有用请点赞,喜欢请关注!秀才在此谢过大家了!!! 在现代计算机系统中,多线程 ...
- Win12不会取代Win11!真正目标是Google
Windows 11之后自然应该是Windows 12,但这一次不太一样. 据多个消息源确认,Windows的下一个重大版本将不会是Windows 11的直接升级版,而是更专注于云和Web,同时大力接 ...
- 俄大神 lopatkin Windows 精简优化系统 - 工具软件
昨天有个网友邮件我,说是想找个Tiny7 Rev2的ISO操作系统文件,但是我找了下,以前的那些文件有些已经删除了,所以就在网上搜到了俄大神 lopatkin Windows 精简优化系统,特此放到网 ...
- 位图|布隆过滤器模拟实现|STL源码剖析系列|手撕STL
今天博主给大家带来位图和布隆过滤器的模拟实现. 前言 那么这里博主先安利一下一些干货满满的专栏啦! 手撕数据结构https://blog.csdn.net/yu_cblog/category_1149 ...