在前面的文章中笔者就Map接口和Map接口的实现原理:内部哈希映射技术做了一个简单的
分析,并且对hashCode方法做了一些阐述。可能有些混乱,不过理解这些是弄懂HashMap
的前提,也能帮助我们更好的解析hashMap的源码。
HashMap是基于哈希表的Map接口的非同步实现,它提供所有可选的映射操作,并允许使
用null键和null值。此集合不保证映射的顺序,特别不保证其顺序永久不变。
首先我们先看下HashMap类的头部:
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable对于它的分析就不多做解释了,AbstractMap类主要是帮助我们自定义自己的Map实现类。
接下来我们看看HashMap的底层是如何实现的。在这之前我们先对数据结构略作分析。
在java语言中,最基本的结构分为两种:其一为数组,其二为模拟指针(引用)说白了就是
链表。所有的数据类型都可以使用上述的两种来构造。
数组的特点是:寻址容易,插入和删除困难;
链表的特点是:寻址困难,插入和删除容易;
思考下:我们能不能结合两者的优点,折中构造一种寻址容易,插入删除也较为容易的
数据结构呢?答案是肯定的了。我们可以构造一种“链表散列”的数据结构,可以理解为链表
的数组,HashMap就是基于其实现的。
从图中可以看出HashMap的底层就是一个数组结构,数组中的每一项又是一个链表。那么
究竟是不是这样呢?我们看源码吧。
/** * The table, resized as necessary. Length MUST Always be a power of two. */ transient Entry<K,V>[] table; static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next; int hash; /** * Creates new entry. */ Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; } ........... }可以看出的是HashMap里面实现了一个静态内部类Entry(记录),其重要的属性有key、value、next
而HashMap有一个属性是Entrr的数组table。Entry就是table数组中的元素,Map.Entry保存一个键值对
和这个键值对持有指向下一个键值对的引用,如此就构成了链表了。
/**根据指定容量和负载因子构造HashMap*/ 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); // Find a power of 2 >= initialCapacity int capacity = 1; while (capacity < initialCapacity) capacity <<= 1; this.loadFactor = loadFactor; threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); table = new Entry[capacity]; useAltHashing = sun.misc.VM.isBooted() && (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD); init(); } /**根据指定的容量和默认的负载因子构造HashMap*/ public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } //默认的空的构造器 public HashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); } /**通过指定一个Map对象进行构造*/ public HashMap(Map<? extends K, ? extends V> m) { this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR); putAllForCreate(m); }上述构造函数可以看出的是就是对table数组进行空间分配,至于那个负载因子到底是怎么回事
这里我们先不做解释。
public V put(K key, V value) { // HashMap允许存放null键和null值。 // 当key为null时,调用putForNullKey方法,将value放置在数组第一个位置。 if (key == null) return putForNullKey(value); // 根据key的keyCode重新计算hash值。 int hash = hash(key);//注意这里的实现是jdk1.7和以前的版本有区别的 // 搜索指定hash值在对应table中的索引。 int i = indexFor(hash, table.length); // 如果 i 索引处的 Entry 不为 null,通过循环不断遍历 e 元素的下一个元素。 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; } } // 如果i索引处的Entry为null,表明此处还没有Entry。 modCount++; // 将key、value添加到i索引处。 addEntry(hash, key, value, i); return null; }
table是线性数组,是如何实现随机存储的呢?
这里是通过下面两行代码来实现的
int hash = hash(key);//注意这里的实现是jdk1.7和以前的版本有区别的 // 搜索指定hash值在对应table中的索引。 int i = indexFor(hash, table.length);通过hash方法的到key对象的哈希码,在通过indexFox()方法生成索引。具体如下:
/**产生哈希码*/ final int hash(Object k) { int h = 0; if (useAltHashing) { if (k instanceof String) { return sun.misc.Hashing.stringHash32((String) k); } h = hashSeed; } h ^= k.hashCode(); // This function ensures that hashCodes that differ only by // constant multiples at each bit position have a bounded // number of collisions (approximately 8 at default load factor). /*加入高位计算,防止低位不变,高位变化是引起hash冲突*/ h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); } /**产生索引,由于索引产生是不确定的,因此也就造成了HashMap顺序的不确定性。 需要注意的是不同的hash产生的索引完全有可能相同的 该方法的实现十分的巧妙,它通过h & (length-1)来的到对象保存的 索引,有可知道底层数组为2的n次方,这在速度上就有了明显的优化 */ static int indexFor(int h, int length) { return h & (length-1); }通过上述代码我们可以很深刻的理解到,通过key值的hashCode方法返回的hash码,来产生
索引i。如果table[i]为null,则此处没有键值对,可以直接插入。如果table[i]!=null则此处有元素
则上面的for循环就是存储的新的元素:
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; } }Tips:上述的key对象的hashCode我们应该主动的去重写,是的其和equals方法的逻辑一致性,
例如一个具体的对象作为一个key,我们通过内容判断是否相等(equals重写),这时我们应该要
主动的去重写hashCode方法,让其和equals方法一样的逻辑结果。如若不然的话,我们认为相等
的key会覆盖,却因为没有重写hashCode实际上没有覆盖!
因为实际我们用String作为key的比较多,也就没有太过注意上述情况。
下面的就是一个错误例子
package com.kiritor; public class Student { String name; public Student(String aa) { // TODO Auto-generated constructor stub name = aa; } @Override public boolean equals(Object obj) { // TODO Auto-generated method stub return this.name.equals(((Student) obj).name); } public static void main(String[] args) throws InterruptedException { HashMap<Student, Object> hashMap = new HashMap<>(); hashMap.put(new Student("AA"), "HEHE"); hashMap.put(new Student("AA"), "HEHE"); System.out.println(new Student("AA").name.equals(new Student("AA").name)); System.out.println(hashMap.size()); } }结果为:true 2 明显和我们的初衷背离了,因此这是我们序注意的地方。
一个有意思的情况出现:
这一问题呢?其实这里就是“链表数组”的IMBA之处了。详细的处理情况还是在for循环中。
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; } }简单的分析下:假设table[0]!=null,其键为key1,当第二次插入的时候key2的哈希码虽然和key1不同,
但是获得的索引却是0,产生了hash冲突。进入for循环体,由于key1、key2的哈希不同,所以if判断为false
之后key1=key1.next(说法不准,这里直接就以key当做键值对元素吧),再然后执行for之后的插入语句
// 如果i索引处的Entry为null,表明此处还没有Entry。 modCount++; // 将key、value添加到i索引处。 addEntry(hash, key, value, i); return null;key2被插入进key1的位置,同时key2.next指向的是key1,ok看明白了吗?这样hash冲突的问题就
通过链表数组的形式被解决了。简单的用图形展示
这里HashMap解决hash冲突的方法就是通过链地址法来的。
这里笔者也给出其他的冲突解决方式,有兴趣的朋友可以研究下:
1)开放定址法(线性探测再散列,二次探测再散列,伪随机探测再散列)
2)再哈希法
3)链地址法
4)建立一 公共溢出区
说完了元素的存储,我们来看看,HashMap是如何来读取元素的吧,这里我们简要的分析
下get(key)方法
public V get(Object key) { if (key == null) return getForNullKey(); Entry<K,V> entry = getEntry(key); return null == entry ? null : entry.getValue(); }对于key为空值的情况,我们就不在详述了,读者朋友可自行参阅jdk源码。
接下来进入getEntry(key)方法体里面去。
final Entry<K,V> getEntry(Object key) { int hash = (key == null) ? 0 : hash(key); for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } return null; }嘿,这不和存储的方式有些相似吗,由hash的到索引,如果索引位置为空,就不存在此key
values返回的就是空。如若索引位置不为空,该位置下可能是一条链,找到这条链里面可key的
hash相同的key,返回其对应的values。呵呵,取元素的方法是否简单多了呢?
对于删除元素的原理和上述都是差不多的,这里笔者也就不解析了嘛。
做的是尽量的避免hash冲突 ,此时对于数组的扩容就应该考虑了。不过一个蛋疼的问题也就
出现了,由于新数组的容量变了,原数组的数据就必须重新计算其再数组中的位置,并放入
这就是resize。同时这也是最消耗性能的地方。
那么在什么情况下对HashMap进行扩容呢?一般当HashMap的元素个事超过数组大小*
*loadFactory的时候,就会进行扩容,而loadFactor就是上文所说的负加载因子。默认值为0.75
例如数组空间为16,当元素超过16*0.75=12的时候就把数组大小扩为2*16=32,然后resize
这是一个非常消耗性能的是,因此如果我们预料到HashMap中元素的个数,这就能够有效的
提高hashMap的性能。
为确定何时调整大小,而不是对每个存储桶中的链接列表的深度进行计数,基于hash的
Map使用一个额外的参数并粗略计算存储桶的密度。Map在调整大小之前,使用名为LoadFactory
的参数指示Map将承担的“负载”量,即它的负载程度。loadFactory、map大小、容量之间关系:
如果(负载因子)x(容量)>(Map 大小),则调整 Map 大小
http://blog.csdn.net/kiritor/article/details/8872565
相关阅读:
Map源码学习 http://blog.csdn.net/kiritor/article/details/8884371
hashCode方法相关 http://blog.csdn.net/kiritor/article/details/8885022