码迷，mamicode.com
首页 > 编程语言 > 详细

java jdk 中HashMap的源码解读

时间：2015-09-17 23:15:15      阅读：282      评论：0      收藏：0      [点我收藏+]

标签：

HashMap是我们在日常写代码时最常用到的一个数据结构，它为我们提供key-value形式的数据存储。同时，它的查询，插入效率都非常高。 

在之前的排序算法总结里面里，我大致学习了HashMap的实现原理，并制作了一个简化版本的HashMap。 今天，趁着项目的间歇期，我又仔细阅读了Java中的HashMap的实现。 

 

HashMap的初始化： 

Java代码 
  1. public HashMap(int initialCapacity, float loadFactor)  
  2.   
  3. public HashMap(int initialCapacity)  
  4.   
  5. public HashMap()  
  6.   
  7. public HashMap(Map<? extends K, ? extends V> m)  

最近看到几篇精彩的文章:

存取之美 —— HashMap原理、源码、实践

Hash碰撞与拒绝服务攻击

这些文章让我收获良多, 但是有些地方说的不够详细, 在此写下本人对上述文章的总结和理解, 希望可以给需要的朋友带来一些帮助.

 

1. 概述

HashMap在底层采用数组+链表的形式存储键值对.

在HashMap中定义了一个内部类Entry<K, V>, 该内部类是对key-value的抽象. Entry类包含4个成员: key, value, hash, next. key和value的意义很清晰, hash表示key的hash值, next是指向下一个Entry对象的引用.

HashMap内部维护了一个Entry<K, V>[] table, 数组table中的Entry元素是一个Entry链表的头结点(理解这一点很重要). 

 

2. put/get方法

向HashMap中添加键值对时, 程序会根据key的hashCode值计算出hash值, 然后对hash值取模, 模数是table.length. 假如取模的结果为index, 则取出table[index]. table[index]可能为null, 也可能是一个Entry对象. 如果为null, 则直接存储. 否则计算key.equals(table[index].key), 如果为false, 就取出table[index].next, 继续调用key的equals方法, 直到equals方法返回true, 或者比较完链表中所有Entry对象.

Java代码 
  1. public V put(K key, V value) {  
  2.     if (key == null)  
  3.         return putForNullKey(value);  
  4.     // 对hashCode值进行二次hash得到最终的hash值  
  5.     int hash = hash(key.hashCode());  
  6.     // 根据hash值定位数组中的索引位置  
  7.     int i = indexFor(hash, table.length);  
  8.     // 遍历table[i]位置处的链表  
  9.     for (Entry<K, V> e = table[i]; e != null; e = e.next) {  
  10.         Object k;  
  11.         // 如果hash值相同且equals返回true, 则替换原来的value值  
  12.         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
  13.             V oldValue = e.value;  
  14.             e.value = value;  
  15.             e.recordAccess(this);  
  16.             return oldValue;  
  17.         }  
  18.     }  
  19.   
  20.     modCount++;  
  21.     // 如果之前函数没有return, 将该键值对插入table[i]链表中  
  22.     addEntry(hash, key, value, i);  
  23.     return null;  
  24. }  

理解了put方法, 那么get方法就会很容易理解:

Java代码 
  1. public V get(Object key) {  
  2.     if (key == null)  
  3.         return getForNullKey();  
  4.     int hash = hash(key.hashCode());  
  5.     // 首先根据hash值计算index, 然后取出index处的链表的头结点. 遍历链表.  
  6.     for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {  
  7.         Object k;  
  8.         if (e.hash == hash && ((k = e.key) == key || key.equals(k)))  
  9.             return e.value;  
  10.     }  
  11.     return null;  
  12. }  

  

3. HashMap的容量和索引位置确定

前面没有叙述HashMap的容量问题, 是因为容量是与索引位置计算紧密相关的.

理解HashMap的容量就需要关注成员变量size, loadFactor, threshold.

size表示HashMap中实际包含的键值对个数.

loadFactor表示负载因子, loadFactor的值越大, 则对table数组的利用率越大, 相当于节省内存空间. 但是loadFactor的值增大, 同时也会导致hash冲突的概率增加, 从而使得程序效率降低. loadFactor的取值应该兼顾内存空间和效率, 默认值为0.75.

threshold表示极限容量, 计算公式为threshold = (int)(capacity * loadFactor);  当size达到threshold时, 就需要对table数组扩容.

HashMap的容量大小就是table.length. 由于java中取模是一个效率低下的操作, 所以出于性能的考虑, HashMap的容量被设计为2的N次方. 如此hash%table.length就可以转换为hash&(table.length-1). 与运算的效率比取模运算高效很多.

Java代码 
  1. public HashMap(int initialCapacity, float loadFactor) {  
  2.     if (initialCapacity < 0)  
  3.         throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);  
  4.     if (initialCapacity > MAXIMUM_CAPACITY)  
  5.         initialCapacity = MAXIMUM_CAPACITY;  
  6.     if (loadFactor <= 0 || Float.isNaN(loadFactor))  
  7.         throw new IllegalArgumentException("Illegal load factor: " + loadFactor);  
  8.   
  9.     // 计算大于initialCapacity的最小的2的N次方数  
  10.     int capacity = 1;  
  11.     while (capacity < initialCapacity)  
  12.         capacity <<= 1;  
  13.   
  14.     this.loadFactor = loadFactor;  
  15.     // 求出极限容量  
  16.     threshold = (int) (capacity * loadFactor);  
  17.     // table的容量被设计为2的N次方  
  18.     table = new Entry[capacity];  
  19.     init();  
  20. }  

如果使用无参的构造函数创建HashMap, 则容量默认为16, 负载因子默认为0.75.

indexFor函数用于确定索引位置:

Java代码 
  1. static int indexFor(int h, int length) {  
  2.     // 当length为2的N次方时相当于h%table.length, 但效率要高效很多  
  3.     return h & (length - 1);  
  4. }  

 

4. rehash

前面提到过, 当size达到threshold时, 就需要对table数组扩容. 调用put函数向HashMap中插入一个键值对时会调用到addEntry(hash, key, value, i)方法:

Java代码 
  1. void addEntry(int hash, K key, V value, int bucketIndex) {  
  2.     // 取出索引处的Entry对象  
  3.     Entry<K, V> e = table[bucketIndex];  
  4.     // 更新索引处链表的头结点, 并使新的头结点的next属性指向原来的头结点  
  5.     table[bucketIndex] = new Entry<K, V>(hash, key, value, e);  
  6.     // 当size大于threshold时扩容数组, 容量增加至原来的2倍. 保证table的容量始终是2的N次方  
  7.     if (size++ >= threshold)  
  8.         resize(2 * table.length);  
  9. }  

resize用于扩容数组. 数组的length增加大了, 那么HashMap中已有的键值对就必须重新进行hash, 这就是rehash. 如果不进行rehash, 就会使得put和get时table数组的length不同, 从而导致get方法无法取出原先put存入的键值对.

Java代码 
  1. void resize(int newCapacity) {  
  2.     Entry[] oldTable = table;  
  3.     int oldCapacity = oldTable.length;  
  4.     if (oldCapacity == MAXIMUM_CAPACITY) {  
  5.         threshold = Integer.MAX_VALUE;  
  6.         return;  
  7.     }  
  8.   
  9.     Entry[] newTable = new Entry[newCapacity];  
  10.     transfer(newTable);  
  11.     table = newTable;  
  12.     threshold = (int) (newCapacity * loadFactor);  
  13. }  
  14. void transfer(Entry[] newTable) {  
  15.     Entry[] src = table;  
  16.     int newCapacity = newTable.length;  
  17.     // 对已有的键值对进行rehash  
  18.     for (int j = 0; j < src.length; j++) {  
  19.         // 得到j处的链表的头结点  
  20.         Entry<K, V> e = src[j];  
  21.         // 遍历链表  
  22.         if (e != null) {  
  23.             src[j] = null;  
  24.             do {  
  25.                 // 进行rehash  
  26.                 Entry<K, V> next = e.next;  
  27.                 int i = indexFor(e.hash, newCapacity);  
  28.                 e.next = newTable[i];  
  29.                 newTable[i] = e;  
  30.                 e = next;  
  31.             } while (e != null);  
  32.         }  
  33.     }  
  34. }  

从源码可以看出, rehash对性能的影响是非常大的, 因此我们应该尽量避免rehash的发生. 这就要求我们预估需要存入HashMap的键值对的数量, 根据数量在创建HashMap对象时指定合适的容量和负载因子.

 

5. hash碰撞和HashMap的退化

hash碰撞在HashMap中的表现为: 不同的key, 计算出相同的index. 如果对所有的key调用indexFor方法的返回值都是相同的, 那么HashMap就退化为链表, 这对性能的影响也是非常大的. 几个月前的闹得沸沸扬扬的hash碰撞攻击就是基于这样的原理.

常用的web框架都会将请求中的参数保存在HashMap(或HashTable)中, 如果客户端根据Web应用框架采用的Hash函数来通过某种Hash攻击的方式获得大量的碰撞, 那么HashMap就会退化为链表, 服务器有可能处理一次请求要花上十几分钟甚至几个小时的时间...

 

6. 线程安全

HashMap是线程不安全的, 如果遍历HashMap的过程中修改了HashMap, 那么就会抛出java.util.ConcurrentModificationException异常:

Java代码 
  1. final Entry<K, V> nextEntry() {  
  2.     if (modCount != expectedModCount)  
  3.         throw new ConcurrentModificationException();  
  4.     Entry<K, V> e = next;  
  5.     if (e == null)  
  6.         throw new NoSuchElementException();  
  7.   
  8.     if ((next = e.next) == null) {  
  9.         Entry[] t = table;  
  10.         while (index < t.length && (next = t[index++]) == null)  
  11.             ;  
  12.     }  
  13.     current = e;  
  14.     return e;  
  15. }  

modCount是HashMap的成员变量, 用于表示HashMap的状态. expectedModCount是遍历初始时modCount的值. 如果在遍历过程中改变了modCount的值就会导致modCount和expectedModCount不相等, 从而抛出异常. put, clear, remove等方法都会导致modCount的值改变.

java jdk 中HashMap的源码解读

标签：

原文地址：http://www.cnblogs.com/wzhanke/p/4817773.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！