一、散列表结构

散列表结构就是数组+链表的结构

二、什么是哈希?

Hash也称散列、哈希,对应的英文单词Hash,基本原理就是把任意长度的输入,通过Hash算法变成固定长度的输出

这个映射的规则就是对应的哈希算法,而原始数据映射后的二进制就是哈希值

Java并发编程学习笔记,关注公众号:程序员追风,回复 013 领取422页PDF文档

不同的数据它对应的哈希码值是不一样的

哈希算法的效率非常高

三、HashMap原理讲解

3.1、继承体系图

3.2、Node数据结构分析

static class Node<K,V> implements Map.Entry<K,V> {
final int hash;计算得到哈希值
final K key;
V value;
Node<K,V> next;
} interface Entry<K, V> {
K getKey();
V getValue();
V setValue(V value);

3.3、底层存储结构

当链表长度到达8时,升级成红黑树结构

3.4、put数据原理分析

首先put进去一个key----value

根据key值会计算出一个hash值

经过扰动使数据更散列

构造出一个node对象

最后在通过路由算法得出一个对应的index

3.5、什么是哈希碰撞?

当传入的数据key对应计算出的hash值的后四位和上一个一样时,这时候计算出的index就会一致,就会发生碰撞,导致数据变成链表

例如:

(16-1)------->0000 0000 0000 1111

“张三”------->0100 1101 0001 1011

“李四”-------->1011 1010 0010 1011

此时,就会发现,张三和李四计算出的hash值转化为二进制的后四位一致,导致计算出index一致

3.6、JDK8为什么引入红黑树?

哈希碰撞,会带来链化,效率会变低

引入红黑树会提高查找效率

3.7、扩容机制

每次扩容为初始容量的2倍

eg:16------->32

为了防止数据过多,导致线性查询,效率变低,扩容使得桶数变多,每条链上数据变少,查询更快

四、手撕源码

4.1、HashMap核心属性分析

树化阈值-----8和64

负载因子0.75

threshold扩容阈值,当哈希表中的元素超过阈值时,触发扩容

loadFactory负载因子0.75,去计算阈值 eg:16*0.75

size-------当前哈希表中元素个数

modCount--------当前哈希表结构修改次数

4.2、构造方法分析

public HashMap(int initialCapacity, float loadFactor) {
//校验 小于0报错
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//capacity大于最大值取最大值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//负载因子不能小于等于0
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//tableSizeFor方法
this.threshold = tableSizeFor(initialCapacity);
} ---------------------------------------------------------
//传入一个初始容量,默认负载因子0.75
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
---------------------------------------------------------
//无参数,负载因子默认0.75
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
---------------------------------------------------------
//传入一个map的对象
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}

4.3、put方法分析

public V put(K key, V value) {
//返回putVal方法,给key进行了一次rehash
return putVal(hash(key), key, value, false, true);
}
----------------------------------------------------------
static final int hash(Object key) {
//让key对应的hash值的高16位也参与运算
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
----------------------------------------------------------
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)
{
//tab:引用当前HashMap的散列表
//p:表示当前散列表的元素
//n:表示散列表数组的长度
//i:表示路由寻址的结果
Node<K,V>[] tab; Node<K,V> p; int n, i;
---------------------------------------------------------- //延迟初始化逻辑,当第一次调用putVal的时候,才去初始化HashMap对象的散列表大小
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
----------------------------------------------------------
//寻找找到桶位,且刚好为null,则把k-v封装成node对象放进去
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
----------------------------------------------------------
else {
//e:不为null时,找到一个与当前要插入的key-val一致的key对象
//k:临时的一个key
Node<K,V> e; K k;
//表示桶位中的该元素,与你当前插入的元素key一致,后续会有替换操作
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
----------------------------------------------------------
//树化
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
----------------------------------------------------------
else {
//链表的情况,而且链表的头元素与我们要插入的key不一致
for (int binCount = 0; ; ++binCount) { //条件成立,即说明迭代到最后一个链表了,也没找到与你要插入的key一致的node对象
//说明要加入到链表的最后
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//说明当前链表长度达到树化标准
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//说明找到的元素key一样,进行替换,break跳出循环即可
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
----------------------------------------------------------
//e不等于null,说明找到了一个与你插入元素完全一致的,进行替换
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
----------------------------------------------------------
//modCount:表示散列表结构被修改次数,替换元素不算次数
++modCount;
//插入新元素,size自增,如果自增大于扩容阈值,则触发扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}

4.4、resize()方法分析

//为了解决哈希冲突,影响哈希效率,所以会有扩容机制
----------------------------------------------------------
final Node<K,V>[] resize() {
//oldTab:引用扩容前的哈希表
//oldCap:表示扩容前table的数组长度
//oldThr:表示扩容之前阈值
//newCap,newThr:扩容后的数组长度大小,以及扩容后下次的阈值
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
----------------------------------------------------------
//条件成立,说明hashmap散列表已经初始化过了,这是一次正常扩容
if (oldCap > 0) {
//扩容之前的table数组大小,已经达到了最大阈值后,则不扩容
//且设置扩容条件为int最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
----------------------------------------------------------
//oldCAP左移一位,实现数值翻倍,且赋值给newcap,newcap小于数值最大值限制 且扩容之前阈值>=16
//这种情况下,则下一次扩容阈值等于当前阈值翻倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
---------------------------------------------------------- //oldCap == 0,说明hashmap散列表为null
//1.new HashMap(inttCap,loadFactor);
//2.new HashMap(inttCap);
//3.new HashMap(map); map有数据
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;//一定是2的次方数
----------------------------------------------------------
//oldCap==0,oldThr==0
//new HashMap();
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
----------------------------------------------------------
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
----------------------------------------------------------
---------------------------------------------------------- //创建一个更长更大的数组
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//说明,hashmap本次扩容之前,table不为null
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;//当前node节点
//说明当前桶位中有数据,但是具体是链表还是红黑树,还是单个数据,不确定
if ((e = oldTab[j]) != null) {
//方便jvm GC时回收
oldTab[j] = null; //说明是个单个元素,直接计算当前元素应存放的新数组的位置即可
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//判断有没有树化成红黑树
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//第三种情况:桶位已经形成链表
else { // preserve order
//地位链表--存放在扩容之后的数组的下标位置,与当前数组的下标位置一致
Node<K,V> loHead = null, loTail=null;
//高位链表--存放在扩容之后的数组的下标位置为当前数组下标位置+扩容之前数组的长度
Node<K,V> hiHead = null, hiTail=null;
----------------------------------------------------------
Node<K,V> next;
do {
next = e.next;
//hash--……1 1111
//hash--……0 1111
//0b 10000
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
}
while ((e = next) != null);
//
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}

4.5、get方法

public V get(Object key) {
Node<K,V> e;
return (e = getNode(key)) == null ? null : e.value;
}
----------------------------------------------------------
final Node<K,V> getNode(Object key) {
Node<K,V>[] tab; //tab:引用当前hashmap的散列表
Node<K,V> first, e;//first:桶位中的头元素,e:临时node元素
int n, hash; //n:table数组长度
K k;
---------------------------------------------------------
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & (hash = hash(key))]) != null) {
//定位出来的桶位元素,就是我们要get的元素
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
---------------------------------------------------------- //说明当前桶位不止一个元素,可能是树或者链表
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
---------------------------------------------------------- //链表的情况
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}

4.6、remove方法分析

public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
----------------------------------------------------------
final Node<K,V> removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {
//tab:引用当前HashMap的散列表
//p:表示当前散列表的元素
//n:表示散列表数组的长度
//index:表示路由寻址的结果
Node<K,V>[] tab; Node<K,V> p; int n, index;
----------------------------------------------------------
if ((tab = table) != null && (n = tab.length) > 0 &&(p = tab[index = (n - 1) & hash]) != null) {
//说明路由的桶位是有数据的,需要进行查找操作,且删除
---------------------------------------------------------- //node:查找到的结果, e:当前node的下一个元素
Node<K,V> node = null, e; K k; V v;
//当前桶位中的元素即为要删除的元素
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
---------------------------------------------------------- //当前桶位的元素为红黑树
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node=((TreeNode<K,V>)p).getTreeNode(hash, key);
---------------------------------------------------------- //当前桶位为链表
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
---------------------------------------------------------- //判断node不为空的情况,说明按照key找到了要删除的数据
if (node != null && (!matchValue || (v = node.value) == value ||(value != null&&value.equals(v)))) {
//结果是红黑树
if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//结果为单个元素
else if (node == p)
tab[index] = node.next;
//结果为链表
else
p.next = node.next;
++modCount;//修改次数自增
--size;//长度减少
afterNodeRemoval(node);
return node;
}
}
return null;
}

4.7、replace方法分析

@Override
public boolean replace(K key, V oldValue, V newValue) {
Node<K,V> e; V v;
if ((e = getNode(key)) != null &&
((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
----------------------------------------------------------
@Override
public V replace(K key, V value) {
Node<K,V> e;
if ((e = getNode(key)) != null) {
V oldValue = e.value;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
return null;
}
ll && v.equals(oldValue)))) {
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
----------------------------------------------------------
@Override
public V replace(K key, V value) {
Node<K,V> e;
if ((e = getNode(key)) != null) {
V oldValue = e.value;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
return null;
}

2021超详细的HashMap原理分析,面试官就喜欢问这个!的更多相关文章

  1. 基础面试,为什么面试官总喜欢问String?

    关于 Java String,这是面试的基础,但是还有很多童鞋不能说清楚,所以本文将简单而又透彻的说明一下那个让你迷惑的 String 在 Java 中,我们有两种方式创建一个字符串 String x ...

  2. 一线大厂面试官最喜欢问的15道Java多线程面试题

    前言 在任何Java面试当中多线程和并发方面的问题都是必不可少的一部分.如果你想获得更多职位,那么你应该准备很多关于多线程的问题. 他们会问面试者很多令人混淆的Java线程问题.面试官只是想确信面试者 ...

  3. Springboot启动扩展点超详细总结,再也不怕面试官问了

    1.背景 Spring的核心思想就是容器,当容器refresh的时候,外部看上去风平浪静,其实内部则是一片惊涛骇浪,汪洋一片.Springboot更是封装了Spring,遵循约定大于配置,加上自动装配 ...

  4. 阿里面试官最喜欢问的21个HashMap面试题

    1.HashMap 的数据结构? A:哈希表结构(链表散列:数组+链表)实现,结合数组和链表的优点.当链表长度超过 8 时,链表转换为红黑树. transient Node<K,V>\[\ ...

  5. 深度分析:面试腾讯,阿里面试官都喜欢问的String源码,看完你学会了吗?

    前言 最近花了两天时间,整理了一下String的源码.这个整理并不全面但是也涵盖了大部分Spring源码中的方法.后续如果有时间还会将剩余的未整理的方法更新到这篇文章中.方便以后的复习和面试使用.如果 ...

  6. 2019年面试官最喜欢问的28道ZooKeeper面试题

    前言 ZooKeeper 是一个分布式的,开放源码的分布式应用程序协调服务.它是一个为分布式应用提供一致性服务的软件,提供的功能包括:配置维护.域名服务.分布式同步.组服务等. ZooKeeper 的 ...

  7. 聊聊CAS - 面试官最喜欢问的并发编程专题

    什么是CAS 学习Java并发编程,CAS(Compare And Set)机制都是一个不得不掌握的知识点.除了通过synchronized进行并发控制外,还可以通过CAS的方式控制,大家熟悉的Ree ...

  8. 一个HashMap能跟面试官扯上半个小时

    一个HashMap能跟面试官扯上半个小时 <安琪拉与面试官二三事>系列文章 一个HashMap能跟面试官扯上半个小时 一个synchronized跟面试官扯了半个小时 一个volatile ...

  9. 走向DBA[MSSQL篇] 面试官最喜欢的问题 ----索引+C#面试题客串

    原文:走向DBA[MSSQL篇] 面试官最喜欢的问题 ----索引+C#面试题客串 对大量数据进行查询时,可以应用到索引技术.索引是一种特殊类型的数据库对象,它保存着数据表中一列或者多列的排序结果,有 ...

随机推荐

  1. watch监听对象的属性

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  2. 一文打尽PWM协议、PPM协议、PCM协议、SBUS协议、XBUS协议、DSM协议 | STM32的通用定时器TIM3实现PPM信号输出

    PWM.PPM.PCM.SBUS.XBUS.DSM都是接收机与其他设备通信的协议. 请注意这里不要将遥控器和接收机之间的协议混淆.遥控器和接收机之间会采用某种协议来互相沟通,这些协议往往各个厂牌各自有 ...

  3. 学习笔记:Kruscal 重构树

    网上感觉没有什么很详细 + 证明的讲解啊) 前置:Kruskal 求最小生成树. 这个算法可以将一棵树 / 无向连通图重构成一颗有性质的新树. 算法可以解决一些树上瓶颈边权之类的问题,可以把需要持久化 ...

  4. 题解-CF1396C Monster Invaders

    题面 CF1396C Monster Invaders 有 \(n\) 层关卡,每层有 \(a_i\) 个小怪(\(1\) 血)和 \(1\) 个老怪(\(2\) 血).有三种武器:\(1\) 武器每 ...

  5. 《深入理解计算机系统》实验三 —— Buf Lab

    这是CSAPP的第三个实验,主要让我们熟悉GDB的使用,理解程序栈帧的结构和缓冲区溢出的原理. 实验目的   本实验的目的在于加深对IA-32函数调用规则和栈结构的具体理解.实验的主要内容是对一个可执 ...

  6. STL(标准模板库)

    STL 主要分为三类: container(容器) - 用来管理一组数据元素 lterator(迭代器) - 可遍历STL容器内全部或部分元素的对象 algorithm(算法) - 对数据进行处理(解 ...

  7. 聊聊Spring的FactoryBean其实没那么难

    前言 谈到Spring的FactoryBean,就会知道Spring中经典的面试题:FactoryBean和BeanFactory的区别.我们这里就简单概括下: . BeanFactory是接口,提供 ...

  8. feign代码自动生成插件

    简介 feign对微服务之间的http调用做了一层封装,如果B项目想调用A项目的一个web服务,只需要编写对应的接口并标注FeignClient注解.但如果接口发生了变更,对应的Feign代码往往会忘 ...

  9. [日常摸鱼]luogu1613跑路

    新年A的第一道题2333 https://www.luogu.org/problemnew/show/P1613 题意:给一张有向图,每条边长为1,每个单位时间只能走$2^k$的长度,$k$可以任意选 ...

  10. SQL注入基本知识点总结

    SQL注入基本知识 information_schema    MySQL 中存储所有数据库名.所有表名.所有字段名的系统数据库叫 information_schema ,这是在 MySQL 数据库初 ...