HashMap实现原理(jdk1.7),源码分析
HashMap实现原理(jdk1.7),源码分析
HashMap是一个用来存储Key-Value键值对的集合,每一个键值对都是一个Entry对象,这些Entry被以某种方式分散在一个数组中,这个数组就是HashMap的主干。
一、几大常量
//默认容量 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//空的哈希表
static final Entry<?,?>[] EMPTY_TABLE = {};
//实际使用的哈希表,存储数据的数组,Entry类型,每个键值对都是一个Entry
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//数组
transient int size;
//阈值
int threshold;
//负载因子
final float loadFactor;
//修改次数,用于多线程问题
transient int modCount;
//使用替代哈希的默认阀值
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
//随机的哈希种子, 有助于减少哈希碰撞的次数
transient int hashSeed = 0;
二、构造器
//以两参构造器为例
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
//传入容量大于最大容量,以最大容量初始容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
this.loadFactor = loadFactor;
threshold = initialCapacity;
init();
}
三、put方法
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
//1.如果hash表为空,则根据阈值扩展
inflateTable(threshold);
}
if (key == null)
//2.键为空的处理方式
return putForNullKey(value);
//3.计算key的哈希值
int hash = haSsh(key);
//4.根据上一步的哈希值得到其再数组中的位置i
int i = indexFor(hash, table.length);
//5.如果i上有元素,则对当前位置的链表进行遍历(HashMap是由数组加链表构成的,一个位置上可能不止有一个元素)
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//5.1. 查看该链表是否有键相同的元素,如果有,就以新值替换旧值,并返回旧值
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
//6.修改次数+1
modCount++;
//7.使用头插法插入Entry对象
addEntry(hash, key, value, i);
return null;
}
put内的方法深入分析:
1. inflateTable(threshold);
private void inflateTable(int toSize) {
//算出一个大于等于toSize的 2的次方数 作为哈希表的容量
int capacity = roundUpToPowerOf2(toSize);
//新的阈值,大小为 容量*负载因子
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
2. putForNullKey(value);
private V putForNullKey(V value) {
//这里可以看到,key为null时和正常的put没什么区别,只不过是直接以数组第一个位置作为插入点
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;
}
3. indexFor(hash, table.length);
//使算得的hash值与 数组长度-1 进行"与"运算
static int indexFor(int h, int length) {
//官方源码注释说的很清楚了,长度必须是非零的2次方数
// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
return h & (length-1);
}
/*
那么为什么一定要是2的次方数呢
假设length=16,那么15的二进制则为0000 1111(以8位表示),
如果h = xxxx 0101, h = xxxx 1111,下面进行"与"运算
0000 1111 0000 1111 0000 1111
xxxx 0101 xxxx 1111 xxxx xxxx
& —————————————— & —————————————— & ——————————————
0000 0101 0000 1111 0000 xxxx
根据上述结果我们可以得出这样的结论:任何一个hash值 & (length-1) 的结果只与hash的后n位有关,
n取决于length是2的几次幂,这样,运算出来的结果一定在0 ~ (length-1)这个范围之内
*/
4. addEntry(hash, key, value, i);
void addEntry(int hash, K key, V value, int bucketIndex) {
//扩容操作,当hash表元素个数大于等于阈值了,并且要插入的位置已经有值了,才进行扩容
if ((size >= threshold) && (null != table[bucketIndex])) {
//扩容位原来容量的2倍
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
//计算元素在数组插入的位置
bucketIndex = indexFor(hash, table.length);
}
//创建新的Entry对象放到对应的位置,使用的是头插法
createEntry(hash, key, value, bucketIndex);
}
5. resize(2 * table.length);
//这是addEntry中的方法,用于对hash表进行扩容,其实就是新建一个长度为newCapaciy的数组,然后把旧数组的元素放到新数组
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, initHashSeedAsNeeded(newCapacity));
//重新指定为新数组引用
table = newTable;
//重新计算阈值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//transfer分析
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
//遍历原hash表,e指向当前元素,next指向e的下一个元素
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//重新计算元素在新数组中应该存入的位置
int i = indexFor(e.hash, newCapacity);
//使用头插法,依次插入新的位置
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
四、get方法
public V get(Object key) {
if (key == null)
//key为空的情况,和上述的putForNullKey相同,也是从数组第一个位置寻找
return getForNullKey();
//遍历数组,根据key的hash值找到数组的位置,然后遍历链表
Entry<K,V> entry = getEntry(key);
//返回key对应的值
return null == entry ? null : entry.getValue();
}
总结
- HashMap(JDK1.7)是由数组加链表的形式存储键值对,每个键值对都是一个Entry对象。
- 默认容量为16,默认负载因子为0.75,默认阈值为12(容量*负载因子),插入的键值对时,如果容器内总个数超过阈值,并且插入的位置不为空,就会进行扩容,扩展为原来的2倍。
- 容量必须为非零的2次幂,详解见上面的indexFor方法
- 每个键值对存入容器的原则是:计算当前key的哈希值,与当前数组长度-1的值进行“与”运算得到插入的位置,如果当前位置为空,则直接将键值对插入数组,如果当前位置有值,则以当前位置的第一个元素为头节点,构成链表,然后让数组该位置存放新的元素。
- 当插入的键为空时,默认放在数组第一个位置,因此HashMap最多只能存放一个key为空的键值对。
- HashMap是线程不安全的。HashMap使用了modCount字段来记录其内部结构发生变化的次数(put方法覆盖某个key对应的value值不属于结构变化)。
HashMap实现原理(jdk1.7),源码分析的更多相关文章
- ConcurrentHashMap底层实现原理(JDK1.8)源码分析
ref:https://blog.csdn.net/xu768840497/article/details/79194701 http://www.cnblogs.com/leesf456/p/545 ...
- 集合之HashMap(含JDK1.8源码分析)
一.前言 之前的List,讲了ArrayList.LinkedList,反映的是两种思想: (1)ArrayList以数组形式实现,顺序插入.查找快,插入.删除较慢 (2)LinkedList以链表形 ...
- Java中HashMap底层实现原理(JDK1.8)源码分析
这几天学习了HashMap的底层实现,但是发现好几个版本的,代码不一,而且看了Android包的HashMap和JDK中的HashMap的也不是一样,原来他们没有指定JDK版本,很多文章都是旧版本JD ...
- HashMap底层实现原理(JDK1.8)源码分析
ref:https://blog.csdn.net/tuke_tuke/article/details/51588156 http://www.cnblogs.com/xiaolovewei/p/79 ...
- 集合之HashSet(含JDK1.8源码分析)
一.前言 我们已经分析了List接口下的ArrayList和LinkedList,以及Map接口下的HashMap.LinkedHashMap.TreeMap,接下来看的是Set接口下HashSet和 ...
- 【集合框架】JDK1.8源码分析之HashMap(一) 转载
[集合框架]JDK1.8源码分析之HashMap(一) 一.前言 在分析jdk1.8后的HashMap源码时,发现网上好多分析都是基于之前的jdk,而Java8的HashMap对之前做了较大的优化 ...
- 【集合框架】JDK1.8源码分析之HashMap & LinkedHashMap迭代器(三)
一.前言 在遍历HashMap与LinkedHashMap时,我们通常都会使用到迭代器,而HashMap的迭代器与LinkedHashMap迭代器是如何工作的呢?下面我们来一起分析分析. 二.迭代器继 ...
- 【集合框架】JDK1.8源码分析HashSet && LinkedHashSet(八)
一.前言 分析完了List的两个主要类之后,我们来分析Set接口下的类,HashSet和LinkedHashSet,其实,在分析完HashMap与LinkedHashMap之后,再来分析HashSet ...
- SpringMVC关于json、xml自动转换的原理研究[附带源码分析 --转
SpringMVC关于json.xml自动转换的原理研究[附带源码分析] 原文地址:http://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-c ...
- 【集合框架】JDK1.8源码分析之ArrayList详解(一)
[集合框架]JDK1.8源码分析之ArrayList详解(一) 一. 从ArrayList字表面推测 ArrayList类的命名是由Array和List单词组合而成,Array的中文意思是数组,Lis ...
随机推荐
- 51nod 1765 谷歌的恐龙
一开始看到了期望吓半死..然后弱弱的写了一下式子.设∑是出去m项之后的和,∑' 是m项的和. E=(n/m)*(∑'/m)+(n/m)*((n-m)/n)*(∑'/m+∑/(n-m))+(n/m)*( ...
- Concurrent包下用过哪些类?
1.executor接口,使用executor接口的子接口ExecutorService用来创建线程池2.Lock接口下的ReentrantLock类,实现同步,比如三个线程循环打印ABCABCABC ...
- 006-PHP检测是否为整数
<?php function checkInteger($Number) { if ($Number > 1) { /* 整数减1仍然是整数 */ return (checkInteger ...
- net.sf.json.JSONObject maven下载到了但是java后台一直用不了问题
需求,实体转JSON,然后用到JSONObject转JSON,但是我向下面这样引入,后台就是用不了,还是报红, <dependency> <groupId>net.sf.jso ...
- 【剑指Offer】面试题26. 树的子结构
题目 输入两棵二叉树A和B,判断B是不是A的子结构.(约定空树不是任意一个树的子结构) B是A的子结构, 即 A中有出现和B相同的结构和节点值. 例如: 给定的树 A: 3 / \ ...
- Web基础之日志
Web基础之日志 日志在企业开发中有着不可或缺的作用,它可以用以记录用户操作.系统运行状态和错误信息.日志记录的好坏直接关系到系统出现问题时定位的速度. 最开始的日志一般使用log4j,后来s ...
- SpringBoot启动流程分析
前景提示 @ComponentScan 的处理都放在org.springframework.context.annotation.ConfigurationClassParser#doProcess ...
- Rabbitmq之高级特性——百分百投递消息&消息确认模式&消息返回模式实现
rabbitmq的高级特性: 如何保障消息的百分之百成功? 要满足4个条件:生产方发送出去,消费方接受到消息,发送方接收到消费者的确认信息,完善的消费补偿机制 解决方案,1)消息落库,进行消息状态打标 ...
- 六十八、SAP中内表插入的三种方法之二,COLLECT的使用,用于计算数字字段之和
一.使用COLLECT时,如果关键字没有,那么插入,如果有则求所有关键字列的和,代码如下 二.sy-index在循环中,每次循环从1开始递增 三.查看T_DATA数据 四.如下 五.循环时候,我们查看 ...
- Node.js 文件系统模块
章节 Node.js 介绍 Node.js 入门 Node.js 模块 Node.js HTTP模块 Node.js 文件系统模块 Node.js URL模块 Node.js NPM Node.js ...