java集合-HashMap源码解析
HashMap 键值对集合
实现原理:
- HashMap 是基于数组 + 链表实现的。
- 通过hash值计算 数组索引,将键值对存到该数组中。
- 如果多个元素hash值相同,通过链表关联,再头部插入新添加的键值对。
- 键值对通过内部类Entity实现。
关键点
HashMap只允许一个为null的key。
HashMap的扩容:当前table数组的两倍
HashMap实际能存储的元素个数: capacity * loadFactor
HashMap在扩容的时候,会重新计算hash值,并对hash的位置进行重新排列, 因此,为了效率,尽量给HashMap指定合适的容量,避免多次扩容
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
{
//默认的HashMap的空间大小16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//hashMap最大的空间大小
static final int MAXIMUM_CAPACITY = 1 << 30;
//HashMap默认负载因子,负载因子越小,hash冲突机率越低,至于为什么,看完下面源码就知道了
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final Entry<?,?>[] EMPTY_TABLE = {};
//table就是HashMap实际存储数组的地方
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE; // transient修饰不会被序列化
//HashMap 实际存储的元素个数
transient int size;
//临界值(即hashMap 实际能存储的大小),公式为(threshold = capacity * loadFactor)
int threshold;
//HashMap 负载因子
final float loadFactor;
// 静态内部类相当于类的一个字段,它可以访问类的其他变量
//HashMap的(key -> value)键值对形式其实是由内部类Entry实现,那么此处就先贴上这个内部类
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
//保存了对下一个元素的引用,说明此处为链表
//为什么此处会用链表来实现?
//其实此处用链表是为了解决hash一致的时候的冲突
//当两个或者多个hash一致的时候,那么就将这两个或者多个元素存储在一个位置,用next来保存对下个元素的引用
Entry<K,V> next;
int hash;
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
// final修饰的方法不能重写
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();
//k1和k2 要么是相同的对象(内存地址相等==),要么对象的值相等(equals且不为null)
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,键的hashCode 和 值的hashCode 与运算。
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
public final String toString() {
return getKey() + "=" + getValue();
}
void recordAccess(HashMap<K,V> m) {
}
void recordRemoval(HashMap<K,V> m) {
}
}
//以上是内部类Entry
//构造方法, 设置HashMap的loadFactor 和 threshold, 方法极其简单,不多说
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();
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//构造方法,传入Map, 将Map转换为HashMap
public HashMap(Map<? extends K, ? extends V> m) {
// 通过this调用自身构造函数
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
//初始化HashMap, 这个方法下面会详细分析
inflateTable(threshold);
//这就是将指定Map转换为HashMap的方法,后面会详细分析
putAllForCreate(m);
}
//初始化HashMap
private void inflateTable(int toSize) {
//计算出大于toSize最临近的2的N次方的值
//假设此处传入6, 那么最临近的值为2的3次方,也就是8
int capacity = roundUpToPowerOf2(toSize);
//由此处可知:threshold = capacity * loadFactor
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//创建Entry数组,这个Entry数组就是HashMap所谓的容器
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
private static int roundUpToPowerOf2(int number) {
//当临界值小于HashMap最大容量时, 返回最接近临界值的2的N次方
//Integer.highestOneBit方法的作用是用来计算指定number最临近的2的N次方的数,内部通过或运算实现的。
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
//这就是将指定Map转换为HashMap的方法,主要看下面的putForCreate方法
private void putAllForCreate(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putForCreate(e.getKey(), e.getValue());
}
private void putForCreate(K key, V value) {
//计算hash值, key为null的时候,hash为0
int hash = null == key ? 0 : hash(key);
//根据hash值,找出当前hash在table中的位置
int i = indexFor(hash, table.length);
//由于table[i]处可能不止有一个元素(多个会形成一个链表),因此,此处写这样一个循环
//当key存在的时候,直接将key的值设置为新值
for (Entry<K,V> e = table[i]; e != null; e = e.next) { // 判断相同hash位置的所有元素,只要有key相同的元素,用新值替换旧值,然后返回
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
//当key不存在的时候,就在table的指定位置新创建一个Entry
createEntry(hash, key, value, i);
}
//在table的指定位置新创建一个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, remove)
//先看put方法
public V put(K key, V value) {
//table为空,就先初始化
if (table == EMPTY_TABLE) {
//这个方法上面已经分析过了,主要是在初始化HashMap,包括创建HashMap保存的元素的数组等操作
inflateTable(threshold);
}
//key 为null的情况, 只允许有一个为null的key
if (key == null)
return putForNullKey(value);
//计算hash
int hash = hash(key);
//根据指定hash,找出在table中的位置
int i = indexFor(hash, table.length);
//table中,同一个位置(也就是同一个hash)可能出现多个元素(链表实现),故此处需要循环
//如果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))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//key 不存在,就在table指定位置之处新增Entry
addEntry(hash, key, value, i);
return null;
}
//当key为null 的处理情况
private V putForNullKey(V value) {
//先看有没有key为null, 有就直接设置新值
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++;、
//当前没有为null的key就新创建一个entry,其在table的位置为0(也就是第一个)
addEntry(0, null, value, 0);
return null;
}
//在table指定位置新增Entry, 这个方法很重要
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
//table容量不够, 该扩容了(两倍table),重点来了,下面将会详细分析
resize(2 * table.length);
//计算hash, null为0
hash = (null != key) ? hash(key) : 0;
//找出指定hash在table中的位置
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
//扩容方法 (newCapacity * loadFactor)
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
//如果之前的HashMap已经扩充打最大了,那么就将临界值threshold设置为最大的int值
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//根据新传入的capacity创建新Entry数组,将table引用指向这个新创建的数组,此时即完成扩容
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
//扩容公式在这儿(newCapacity * loadFactor)
//通过这个公式也可看出,loadFactor设置得越小,遇到hash冲突的几率就越小
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//扩容之后,重新计算hash,然后再重新根据hash分配位置,
//由此可见,为了保证效率,如果能指定合适的HashMap的容量,会更合适
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
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;
}
}
}
//上面看了put方法,接下来就看看remove
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
//这就是remove的核心方法
final Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
//老规矩,先计算hash,然后通过hash寻找在table中的位置
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
Entry<K,V> prev = table[i];
Entry<K,V> e = prev;
//这儿又神奇地回到了怎么删除链表的问题(上次介绍linkedList的时候,介绍过)
//李四左手牵着张三,右手牵着王五,要删除李四,那么直接让张三牵着王五的手就OK
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;
}
}
参考:
- HashMap其实就那么一回事儿之源码浅析 http://www.cnblogs.com/dongying/p/4022795.html
java集合-HashMap源码解析的更多相关文章
- Java集合---HashMap源码剖析
一.HashMap概述二.HashMap的数据结构三.HashMap源码分析 1.关键属性 2.构造方法 3.存储数据 4.调整大小 5.数据读取 ...
- [转载] Java集合---HashMap源码剖析
转载自http://www.cnblogs.com/ITtangtang/p/3948406.html 一.HashMap概述 HashMap基于哈希表的 Map 接口的实现.此实现提供所有可选的映射 ...
- Java集合-ArrayList源码解析-JDK1.8
◆ ArrayList简介 ◆ ArrayList 是一个数组队列,相当于 动态数组.与Java中的数组相比,它的容量能动态增长.它继承于AbstractList,实现了List, RandomAcc ...
- 一、基础篇--1.2Java集合-HashMap源码解析
https://www.cnblogs.com/chengxiao/p/6059914.html 散列表 哈希表是根据关键码值而直接进行访问的数据结构.也就是说,它能通过把关键码值映射到表中的一个位 ...
- Java集合---LinkedList源码解析
一.源码解析1. LinkedList类定义2.LinkedList数据结构原理3.私有属性4.构造方法5.元素添加add()及原理6.删除数据remove()7.数据获取get()8.数据复制clo ...
- java集合-HashSet源码解析
HashSet 无序集合类 实现了Set接口 内部通过HashMap实现 // HashSet public class HashSet<E> extends AbstractSet< ...
- java集合类型源码解析之ArrayList
前言 作为一个老码农,不仅要谈架构.谈并发,也不能忘记最基础的语言和数据结构,因此特开辟这个系列的文章,争取每个月写1~2篇关于java基础知识的文章,以温故而知新. 如无特别之处,这个系列文章所使用 ...
- java集合类型源码解析之PriorityQueue
本来第二篇想解析一下LinkedList,不过扫了一下源码后,觉得LinkedList的实现比较简单,没有什么意思,于是移步PriorityQueue. PriorityQueue通过数组实现了一个堆 ...
- Java 8 HashMap 源码解析
HashMap 使用数组.链表和红黑树存储键值对,当链表足够长时,会转换为红黑树.HashMap 是非线程安全的. HashMap 中的常量 static final int DEFAULT_INIT ...
随机推荐
- 与其争论java和.net的差别,还不如多想点用编程技术挣钱的方式
年前和最近,我发现在博客园和其它地方,有不少争论java和.net哪个好的文章,其实这是种好现象.虽然到了架构层面,技术是通用的,但兼听则明,而且技多不压身,多种挣钱的方式总不会错. 本人最近主攻Ja ...
- service相关
本篇仍以问题为驱动 一.什么时Service? Service是Android程序中四大基础组件之一,它和Activity一样都是Context的子类,只不过它没有UI界面,是在后台运行的组件.Ser ...
- java~google样式检查和命名规范
对于代码的样式和各种元素的命名都是我们架构师需要考虑的,目前在java世界里,比较流行使用java的规范,包括了代码样式检查. 代码样式检查插件 样式文件xml google命名规范 一 代码样式检查 ...
- Fescar(Seata)-Springcloud流程分析-2阶段
上文我们分析了fescar的一阶段执行过程.在一阶段中,服务起始方发起全局事务并注册到TC.在调用协同服务时,协同服务的事务分支事务会先完成阶段一的事务提交或回滚,并生成事务回滚的undo_log日志 ...
- 卷积神经网络 CNN 学习笔记
激活函数Relu 最近几年卷积神经网络中,激活函数往往不选择sigmoid或tanh函数,而是选择relu函数.Relu函数的定义 $$f(x)= max(0,x)$$ Relu函数图像如下图所示: ...
- Vue基础(环境配置、内部指令、全局API、选项、内置组件)
1.环境配置 安装VsCode 安装包管理工具:直接下载 NodeJS 进行安装即可,NodeJS自带 Npm 包管理工具,下载地址:https://nodejs.org/en/download/安装 ...
- 微信公众号开发C#系列-6、消息管理-普通消息接受处理
1.概述 通过前面章节的学习,我们已经对微信的开发有了基本的掌握与熟悉,基本可以上手做复杂的应用了.本篇我们将详细讲解微信消息管理中普通消息的接收与处理.当普通微信用户向公众账号发消息时,微信服务器将 ...
- 时序数据库连载系列:指标届的独角兽Prometheus
简介 Prometheus是SoundCloud公司开发的一站式监控告警平台,依赖少,功能齐全.于2016年加入CNCF,广泛用于 Kubernetes集群的监控系统中,2018.8月成为继K8S之后 ...
- 使用JsonProperty Attribute修改返回json
使用JsonProperty Attribute修改返回 json 值的name 本例使用JsonPropertyAttribute在序列化为JSON时更改属性的名称. public class Vi ...
- mysql-8.0 安装教程(自定义配置文件,密码方式已修改)
下载zip安装包: MySQL8.0 For Windows zip包下载地址:https://dev.mysql.com/downloads/file/?id=476233,进入页面后可以不登录.后 ...