HashMap 键值对集合

实现原理:

  • HashMap 是基于数组 + 链表实现的。
  • 通过hash值计算 数组索引,将键值对存到该数组中。
  • 如果多个元素hash值相同,通过链表关联,再头部插入新添加的键值对。
  • 键值对通过内部类Entity实现。

关键点

  1. HashMap只允许一个为null的key。

  2. HashMap的扩容:当前table数组的两倍

  3. HashMap实际能存储的元素个数: capacity * loadFactor

  4. HashMap在扩容的时候,会重新计算hash值,并对hash的位置进行重新排列, 因此,为了效率,尽量给HashMap指定合适的容量,避免多次扩容

  1. public class HashMap<K,V>
  2. extends AbstractMap<K,V>
  3. implements Map<K,V>, Cloneable, Serializable
  4. {
  5. //默认的HashMap的空间大小16
  6. static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
  7. //hashMap最大的空间大小
  8. static final int MAXIMUM_CAPACITY = 1 << 30;
  9. //HashMap默认负载因子,负载因子越小,hash冲突机率越低,至于为什么,看完下面源码就知道了
  10. static final float DEFAULT_LOAD_FACTOR = 0.75f;
  11. static final Entry<?,?>[] EMPTY_TABLE = {};
  12. //table就是HashMap实际存储数组的地方
  13. transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE; // transient修饰不会被序列化
  14. //HashMap 实际存储的元素个数
  15. transient int size;
  16. //临界值(即hashMap 实际能存储的大小),公式为(threshold = capacity * loadFactor)
  17. int threshold;
  18. //HashMap 负载因子
  19. final float loadFactor;
  20. // 静态内部类相当于类的一个字段,它可以访问类的其他变量
  21. //HashMap的(key -> value)键值对形式其实是由内部类Entry实现,那么此处就先贴上这个内部类
  22. static class Entry<K,V> implements Map.Entry<K,V> {
  23. final K key;
  24. V value;
  25. //保存了对下一个元素的引用,说明此处为链表
  26. //为什么此处会用链表来实现?
  27. //其实此处用链表是为了解决hash一致的时候的冲突
  28. //当两个或者多个hash一致的时候,那么就将这两个或者多个元素存储在一个位置,用next来保存对下个元素的引用
  29. Entry<K,V> next;
  30. int hash;
  31. Entry(int h, K k, V v, Entry<K,V> n) {
  32. value = v;
  33. next = n;
  34. key = k;
  35. hash = h;
  36. }
  37. // final修饰的方法不能重写
  38. public final K getKey() {
  39. return key;
  40. }
  41. public final V getValue() {
  42. return value;
  43. }
  44. // 设置新值后,返回旧值
  45. public final V setValue(V newValue) {
  46. V oldValue = value;
  47. value = newValue;
  48. return oldValue;
  49. }
  50. // 判断键值对是否相等
  51. public final boolean equals(Object o) {
  52. if (!(o instanceof Map.Entry))
  53. return false;
  54. Map.Entry e = (Map.Entry)o;
  55. Object k1 = getKey();
  56. Object k2 = e.getKey();
  57. //k1和k2 要么是相同的对象(内存地址相等==),要么对象的值相等(equals且不为null)
  58. if (k1 == k2 || (k1 != null && k1.equals(k2))) {
  59. Object v1 = getValue();
  60. Object v2 = e.getValue();
  61. if (v1 == v2 || (v1 != null && v1.equals(v2)))
  62. return true;
  63. }
  64. return false;
  65. }
  66. // 键值对的hashCode,键的hashCode 和 值的hashCode 与运算。
  67. public final int hashCode() {
  68. return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
  69. }
  70. public final String toString() {
  71. return getKey() + "=" + getValue();
  72. }
  73. void recordAccess(HashMap<K,V> m) {
  74. }
  75. void recordRemoval(HashMap<K,V> m) {
  76. }
  77. }
  78. //以上是内部类Entry
  79. //构造方法, 设置HashMap的loadFactor 和 threshold, 方法极其简单,不多说
  80. public HashMap(int initialCapacity, float loadFactor) {
  81. if (initialCapacity < 0)
  82. throw new IllegalArgumentException("Illegal initial capacity: " +
  83. initialCapacity);
  84. if (initialCapacity > MAXIMUM_CAPACITY)
  85. initialCapacity = MAXIMUM_CAPACITY;
  86. if (loadFactor <= 0 || Float.isNaN(loadFactor))
  87. throw new IllegalArgumentException("Illegal load factor: " +
  88. loadFactor);
  89. this.loadFactor = loadFactor;
  90. threshold = initialCapacity;
  91. init();
  92. }
  93. public HashMap(int initialCapacity) {
  94. this(initialCapacity, DEFAULT_LOAD_FACTOR);
  95. }
  96. public HashMap() {
  97. this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
  98. }
  99. //构造方法,传入Map, 将Map转换为HashMap
  100. public HashMap(Map<? extends K, ? extends V> m) {
  101. // 通过this调用自身构造函数
  102. this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
  103. DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
  104. //初始化HashMap, 这个方法下面会详细分析
  105. inflateTable(threshold);
  106. //这就是将指定Map转换为HashMap的方法,后面会详细分析
  107. putAllForCreate(m);
  108. }
  109. //初始化HashMap
  110. private void inflateTable(int toSize) {
  111. //计算出大于toSize最临近的2的N次方的值
  112. //假设此处传入6, 那么最临近的值为2的3次方,也就是8
  113. int capacity = roundUpToPowerOf2(toSize);
  114. //由此处可知:threshold = capacity * loadFactor
  115. threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
  116. //创建Entry数组,这个Entry数组就是HashMap所谓的容器
  117. table = new Entry[capacity];
  118. initHashSeedAsNeeded(capacity);
  119. }
  120. private static int roundUpToPowerOf2(int number) {
  121. //当临界值小于HashMap最大容量时, 返回最接近临界值的2的N次方
  122. //Integer.highestOneBit方法的作用是用来计算指定number最临近的2的N次方的数,内部通过或运算实现的。
  123. return number >= MAXIMUM_CAPACITY
  124. ? MAXIMUM_CAPACITY
  125. : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
  126. }
  127. //这就是将指定Map转换为HashMap的方法,主要看下面的putForCreate方法
  128. private void putAllForCreate(Map<? extends K, ? extends V> m) {
  129. for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
  130. putForCreate(e.getKey(), e.getValue());
  131. }
  132. private void putForCreate(K key, V value) {
  133. //计算hash值, key为null的时候,hash为0
  134. int hash = null == key ? 0 : hash(key);
  135. //根据hash值,找出当前hash在table中的位置
  136. int i = indexFor(hash, table.length);
  137. //由于table[i]处可能不止有一个元素(多个会形成一个链表),因此,此处写这样一个循环
  138. //当key存在的时候,直接将key的值设置为新值
  139. for (Entry<K,V> e = table[i]; e != null; e = e.next) { // 判断相同hash位置的所有元素,只要有key相同的元素,用新值替换旧值,然后返回
  140. Object k;
  141. if (e.hash == hash &&
  142. ((k = e.key) == key || (key != null && key.equals(k)))) {
  143. e.value = value;
  144. return;
  145. }
  146. }
  147. //当key不存在的时候,就在table的指定位置新创建一个Entry
  148. createEntry(hash, key, value, i);
  149. }
  150. //在table的指定位置新创建一个Entry
  151. void createEntry(int hash, K key, V value, int bucketIndex) {
  152. Entry<K,V> e = table[bucketIndex];
  153. table[bucketIndex] = new Entry<>(hash, key, value, e);
  154. size++;
  155. }
  156. //下面就开始分析我们常用的方法了(put, remove)
  157. //先看put方法
  158. public V put(K key, V value) {
  159. //table为空,就先初始化
  160. if (table == EMPTY_TABLE) {
  161. //这个方法上面已经分析过了,主要是在初始化HashMap,包括创建HashMap保存的元素的数组等操作
  162. inflateTable(threshold);
  163. }
  164. //key 为null的情况, 只允许有一个为null的key
  165. if (key == null)
  166. return putForNullKey(value);
  167. //计算hash
  168. int hash = hash(key);
  169. //根据指定hash,找出在table中的位置
  170. int i = indexFor(hash, table.length);
  171. //table中,同一个位置(也就是同一个hash)可能出现多个元素(链表实现),故此处需要循环
  172. //如果key已经存在,那么直接设置新值
  173. for (Entry<K,V> e = table[i]; e != null; e = e.next) {
  174. Object k;
  175. if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
  176. V oldValue = e.value;
  177. e.value = value;
  178. e.recordAccess(this);
  179. return oldValue;
  180. }
  181. }
  182. modCount++;
  183. //key 不存在,就在table指定位置之处新增Entry
  184. addEntry(hash, key, value, i);
  185. return null;
  186. }
  187. //当key为null 的处理情况
  188. private V putForNullKey(V value) {
  189. //先看有没有key为null, 有就直接设置新值
  190. for (Entry<K,V> e = table[0]; e != null; e = e.next) {
  191. if (e.key == null) {
  192. V oldValue = e.value;
  193. e.value = value;
  194. e.recordAccess(this);
  195. return oldValue;
  196. }
  197. }
  198. modCount++;、
  199. //当前没有为null的key就新创建一个entry,其在table的位置为0(也就是第一个)
  200. addEntry(0, null, value, 0);
  201. return null;
  202. }
  203. //在table指定位置新增Entry, 这个方法很重要
  204. void addEntry(int hash, K key, V value, int bucketIndex) {
  205. if ((size >= threshold) && (null != table[bucketIndex])) {
  206. //table容量不够, 该扩容了(两倍table),重点来了,下面将会详细分析
  207. resize(2 * table.length);
  208. //计算hash, null为0
  209. hash = (null != key) ? hash(key) : 0;
  210. //找出指定hash在table中的位置
  211. bucketIndex = indexFor(hash, table.length);
  212. }
  213. createEntry(hash, key, value, bucketIndex);
  214. }
  215. //扩容方法 (newCapacity * loadFactor)
  216. void resize(int newCapacity) {
  217. Entry[] oldTable = table;
  218. int oldCapacity = oldTable.length;
  219. //如果之前的HashMap已经扩充打最大了,那么就将临界值threshold设置为最大的int值
  220. if (oldCapacity == MAXIMUM_CAPACITY) {
  221. threshold = Integer.MAX_VALUE;
  222. return;
  223. }
  224. //根据新传入的capacity创建新Entry数组,将table引用指向这个新创建的数组,此时即完成扩容
  225. Entry[] newTable = new Entry[newCapacity];
  226. transfer(newTable, initHashSeedAsNeeded(newCapacity));
  227. table = newTable;
  228. //扩容公式在这儿(newCapacity * loadFactor)
  229. //通过这个公式也可看出,loadFactor设置得越小,遇到hash冲突的几率就越小
  230. threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
  231. }
  232. //扩容之后,重新计算hash,然后再重新根据hash分配位置,
  233. //由此可见,为了保证效率,如果能指定合适的HashMap的容量,会更合适
  234. void transfer(Entry[] newTable, boolean rehash) {
  235. int newCapacity = newTable.length;
  236. for (Entry<K,V> e : table) {
  237. while(null != e) {
  238. Entry<K,V> next = e.next;
  239. if (rehash) {
  240. e.hash = null == e.key ? 0 : hash(e.key);
  241. }
  242. int i = indexFor(e.hash, newCapacity);
  243. e.next = newTable[i];
  244. newTable[i] = e;
  245. e = next;
  246. }
  247. }
  248. }
  249. //上面看了put方法,接下来就看看remove
  250. public V remove(Object key) {
  251. Entry<K,V> e = removeEntryForKey(key);
  252. return (e == null ? null : e.value);
  253. }
  254. //这就是remove的核心方法
  255. final Entry<K,V> removeEntryForKey(Object key) {
  256. if (size == 0) {
  257. return null;
  258. }
  259. //老规矩,先计算hash,然后通过hash寻找在table中的位置
  260. int hash = (key == null) ? 0 : hash(key);
  261. int i = indexFor(hash, table.length);
  262. Entry<K,V> prev = table[i];
  263. Entry<K,V> e = prev;
  264. //这儿又神奇地回到了怎么删除链表的问题(上次介绍linkedList的时候,介绍过)
  265. //李四左手牵着张三,右手牵着王五,要删除李四,那么直接让张三牵着王五的手就OK
  266. while (e != null) {
  267. Entry<K,V> next = e.next;
  268. Object k;
  269. if (e.hash == hash &&
  270. ((k = e.key) == key || (key != null && key.equals(k)))) {
  271. modCount++;
  272. size--;
  273. if (prev == e)
  274. table[i] = next;
  275. else
  276. prev.next = next;
  277. e.recordRemoval(this);
  278. return e;
  279. }
  280. prev = e;
  281. e = next;
  282. }
  283. return e;
  284. }
  285. }

 

参考:

java集合-HashMap源码解析的更多相关文章

  1. Java集合---HashMap源码剖析

    一.HashMap概述二.HashMap的数据结构三.HashMap源码分析     1.关键属性     2.构造方法     3.存储数据     4.调整大小 5.数据读取           ...

  2. [转载] Java集合---HashMap源码剖析

    转载自http://www.cnblogs.com/ITtangtang/p/3948406.html 一.HashMap概述 HashMap基于哈希表的 Map 接口的实现.此实现提供所有可选的映射 ...

  3. Java集合-ArrayList源码解析-JDK1.8

    ◆ ArrayList简介 ◆ ArrayList 是一个数组队列,相当于 动态数组.与Java中的数组相比,它的容量能动态增长.它继承于AbstractList,实现了List, RandomAcc ...

  4. 一、基础篇--1.2Java集合-HashMap源码解析

    https://www.cnblogs.com/chengxiao/p/6059914.html  散列表 哈希表是根据关键码值而直接进行访问的数据结构.也就是说,它能通过把关键码值映射到表中的一个位 ...

  5. Java集合---LinkedList源码解析

    一.源码解析1. LinkedList类定义2.LinkedList数据结构原理3.私有属性4.构造方法5.元素添加add()及原理6.删除数据remove()7.数据获取get()8.数据复制clo ...

  6. java集合-HashSet源码解析

    HashSet 无序集合类 实现了Set接口 内部通过HashMap实现 // HashSet public class HashSet<E> extends AbstractSet< ...

  7. java集合类型源码解析之ArrayList

    前言 作为一个老码农,不仅要谈架构.谈并发,也不能忘记最基础的语言和数据结构,因此特开辟这个系列的文章,争取每个月写1~2篇关于java基础知识的文章,以温故而知新. 如无特别之处,这个系列文章所使用 ...

  8. java集合类型源码解析之PriorityQueue

    本来第二篇想解析一下LinkedList,不过扫了一下源码后,觉得LinkedList的实现比较简单,没有什么意思,于是移步PriorityQueue. PriorityQueue通过数组实现了一个堆 ...

  9. Java 8 HashMap 源码解析

    HashMap 使用数组.链表和红黑树存储键值对,当链表足够长时,会转换为红黑树.HashMap 是非线程安全的. HashMap 中的常量 static final int DEFAULT_INIT ...

随机推荐

  1. 与其争论java和.net的差别,还不如多想点用编程技术挣钱的方式

    年前和最近,我发现在博客园和其它地方,有不少争论java和.net哪个好的文章,其实这是种好现象.虽然到了架构层面,技术是通用的,但兼听则明,而且技多不压身,多种挣钱的方式总不会错. 本人最近主攻Ja ...

  2. service相关

    本篇仍以问题为驱动 一.什么时Service? Service是Android程序中四大基础组件之一,它和Activity一样都是Context的子类,只不过它没有UI界面,是在后台运行的组件.Ser ...

  3. java~google样式检查和命名规范

    对于代码的样式和各种元素的命名都是我们架构师需要考虑的,目前在java世界里,比较流行使用java的规范,包括了代码样式检查. 代码样式检查插件 样式文件xml google命名规范 一 代码样式检查 ...

  4. Fescar(Seata)-Springcloud流程分析-2阶段

    上文我们分析了fescar的一阶段执行过程.在一阶段中,服务起始方发起全局事务并注册到TC.在调用协同服务时,协同服务的事务分支事务会先完成阶段一的事务提交或回滚,并生成事务回滚的undo_log日志 ...

  5. 卷积神经网络 CNN 学习笔记

    激活函数Relu 最近几年卷积神经网络中,激活函数往往不选择sigmoid或tanh函数,而是选择relu函数.Relu函数的定义 $$f(x)= max(0,x)$$ Relu函数图像如下图所示: ...

  6. Vue基础(环境配置、内部指令、全局API、选项、内置组件)

    1.环境配置 安装VsCode 安装包管理工具:直接下载 NodeJS 进行安装即可,NodeJS自带 Npm 包管理工具,下载地址:https://nodejs.org/en/download/安装 ...

  7. 微信公众号开发C#系列-6、消息管理-普通消息接受处理

    1.概述 通过前面章节的学习,我们已经对微信的开发有了基本的掌握与熟悉,基本可以上手做复杂的应用了.本篇我们将详细讲解微信消息管理中普通消息的接收与处理.当普通微信用户向公众账号发消息时,微信服务器将 ...

  8. 时序数据库连载系列:指标届的独角兽Prometheus

    简介 Prometheus是SoundCloud公司开发的一站式监控告警平台,依赖少,功能齐全.于2016年加入CNCF,广泛用于 Kubernetes集群的监控系统中,2018.8月成为继K8S之后 ...

  9. 使用JsonProperty Attribute修改返回json

    使用JsonProperty Attribute修改返回 json 值的name 本例使用JsonPropertyAttribute在序列化为JSON时更改属性的名称. public class Vi ...

  10. mysql-8.0 安装教程(自定义配置文件,密码方式已修改)

    下载zip安装包: MySQL8.0 For Windows zip包下载地址:https://dev.mysql.com/downloads/file/?id=476233,进入页面后可以不登录.后 ...