java.util.HashMap源码解析
2017-06-15 12:32
567 查看
1.java集合框架图
2.所属包
package java.util;
3.继承与实现关系
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
4.准备知识
HashMap是基于哈希表的非同步的实现,不保证映射的顺序永久不变,可以键值对都为null。哈希表的核心就是根据元素求位置。而多个元素可能出现相同的位置,那么就叫冲突。解决冲突的常用方式:链地址法:将多个值的不同的哈希结果(哈希值)用数组进行存储,然后将产生相同哈希值的元素,以单向链表的形式进行存储。所以拉链法的套路就是数组+单链表。第二种解决方式是线性探测法:将多个值余上表长度,如果多个值产生相同的哈希值,那么就依次往下寻找位置,直到不冲突为止。线性探测法致命的缺点就是当数据量上来时,就会频繁的进行碰撞冲突,然后找到位置比较费劲。5.属性
/** * 默认初始化容量为16 */ static final int DEFAULT_INITIAL_CAPACITY = 16; /** * 最大容量,必须是2的n次幂 */ static final int MAXIMUM_CAPACITY = 1 << 30; /** * 默认加载因子 */ static final float DEFAULT_LOAD_FACTOR = 0.75f; /** * 存储数据的Entry数组,是存储实体的数组,长度是2的幂 */ transient Entry<K,V>[] table; /** * 映射键值对的个数,也是数组中元素的个数 */ transient int size; /** * 临界值,当实际大小超过临界值时,会进行扩容threshold = 加载因子*容量 */ int threshold; /** * 哈希表的加载因子 */ final float loadFactor; /** * 被修改的次数 */ transient int modCount;
6.HashMap中链地址的单链表结构
static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next;//指向下一个相同hash值得元素 int hash;//哈希值 Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; } ............. ............. }
7.构造方法
/**构造方法1: * 初始化一个Entry数组,数组大小为2的n次幂 */ public HashMap(int initialCapacity, float loadFactor) { //如果初始化容量小于0,报非法参数异常 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); //如果初始化容量大于最大容量,那么将最大容量作为初始化容量 if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; //如果加载因子小于0或者为非小数,那么就报非法参数异常 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); // 让容量以2的n次幂递增,这样保证了容量大小为偶数 int capacity = 1; while (capacity < initialCapacity) capacity <<= 1; this.loadFactor = loadFactor; threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); //以定义的容量capacity初始化Entry数组 table = new Entry[capacity]; useAltHashing = sun.misc.VM.isBooted() && (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD); init(); }
/**构造方法2 * 使用默认的加载因子和初始化容量构造HashMap */ public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
/**构造方法3 * 使用默认的初始化容量16,和默认的加载因子0.75构造HashMap */ public HashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); }
/**构造方法4 * 构造一个映射关系与指定 Map 相同的 HashMap。 * 所创建的 HashMap 具有默认的加载因子 (0.75) 和足以容纳指定 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); } //遍历m获取值,放入哈希表 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值为0,如果键不为空,那么就通过键来生成hash值 int hash = null == key ? 0 : hash(key); //通过hash值来获取索引 int i = indexFor(hash, table.length); /** * 通过索引查找到table中的Entry节点,进行遍历单链表中的Entry节点。 * 如果出现了该索引对应hash值和键都相同的,那么就直接退出该方法。 */ for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { e.value = value; return; } } //否则就执行createEntry方法创建该桶 createEntry(hash, key, value, i); }
8.方法
createEntry:void createEntry(int hash, K key, V value, int bucketIndex) { //根据索引得出对应定义的Entry类型对象e Entry<K,V> e = table[bucketIndex]; //将e进行初始化哈希值、键、值,以及单链表指向的下一个节点e table[bucketIndex] = new Entry<>(hash, key, value, e); size++; }如果没有相同的hash值和键,那么就会采用上面的方法来创建Entry。就是使用构造器初始化Entry。
hash:
/** * 根据键来获取对应的hash值 */ 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(); h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }使用键来获取对应的hash值,方法首先是进行了hashcode方法先散列一次,然后再进行右移和异或运算。
indexFor:
/** * 返回hash值对应的索引。 */ static int indexFor(int h, int length) { return h & (length-1); }
在我们自己实现哈希表的时候,常常会采用取%的方式来进行散列,将余数作为散列码。但是java采用的是二进制与运算来取hash值。由于length为2的n次幂,所以其减一为奇数,那么转化为二进制,末位肯定是1。如果hash值h为奇数,那么h与length的与运算,返回索引的二进制末位为1.如果hash值h为偶数,那么h与length的与运算,返回索引的二进制末位为0。这就相当于取模运算了,但是与位运算比取模速度快很多。并且这样也可以保证数组的下标不会越界。是一个很棒的选择。由于与运算加上前面hash(key)函数的高位运算,就减少了碰撞。这样就保证了hash值分布比较均匀并且冲突的概率很低。并且只有在值相同时,才会对应数组中的相同位置Entry,然后以next的形式构成链表。
put方法:
/** * 将指定值与此映射中指定的键关联。如果映射以前包含了键的映射,则替换旧值。 */ public V put(K key, V value) { if (key == null) return putForNullKey(value); //通过键获取hash值 int hash = hash(key); //通过hash值获取下标索引 int i = indexFor(hash, table.length); /** * 如果hash值和键都相同的话,那么就返回对应的旧的值。 * 然后新值覆盖旧值。 */ 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++; //否则就添加新值并且返回为空 addEntry(hash, key, value, i); return null; }
/** * 如果当键为空时且键相同,就查找表,如果值也相同,那么就返回旧值。 * 否则就添加新值且返回空 */ private V putForNullKey(V value) { 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++; addEntry(0, null, value, 0); return null; }addEntry方法:
/** * 添加新的值 */ void addEntry(int hash, K key, V value, int bucketIndex) { /** * 映射键值对数目超出了临界值的情况。 * 创建新表容量为原来旧表的二倍,将旧表元素转移到新表。 * 然后通过键生成新的hash值。 * 然后通过新的hash值获取对应的下标索引 */ if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length); hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } //通过新的hash值、键、值、下标索引来以构造器的方式创建Entry createEntry(hash, key, value, bucketIndex); }resize方法:
/** * 就是将HashMap就行扩容操作 */ void resize(int newCapacity) { Entry[] oldTable = table; int oldCapacity = oldTable.length; //如果旧的容量值都已经达到最大容量,那么就不再进行扩容调整了,直接退出了 if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; } //根据新容量长度定义新的数组 Entry[] newTable = new Entry[newCapacity]; boolean oldAltHashing = useAltHashing; useAltHashing |= sun.misc.VM.isBooted() && (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD); boolean rehash = oldAltHashing ^ useAltHashing; //定义了新容量的数组,那么这步就是将旧容量数组中的元素都放到新容量的数组中去 transfer(newTable, rehash); //然后更新当前的Entry数组,也可以说更新桶 table = newTable; //然后临界值也由新容量进行调整 threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); }transfer方法:
/** * 将旧表中的元素都转移到新表中 */ void transfer(Entry[] newTable, boolean rehash) { //获取新表的容量 int newCapacity = newTable.length; //遍历旧表中的Entry,然后通过旧表中的Entry创建新表的Entry。 for (Entry<K,V> e : table) { while(null != e) { Entry<K,V> next = e.next; //如果需要就重新通过键生成hash值 if (rehash) { e.hash = null == e.key ? 0 : hash(e.key); } //通过hash值获取下标索引 int i = indexFor(e.hash, newCapacity); //设置当前Entry节点e指向的下一个节点Entry值为newTable[i] e.next = newTable[i]; //将遍历到的Entry作为新表下标索引对应的值 newTable[i] = e; //单链表循环的条件 e = next; } } }可以看到为了转移元素,使用旧的值生成hash值,再重新计算下标索引的位置,用了两层循环,时间复杂度增加了数量级,非常消耗性能。所以如果我们已知了需要的空间,那么就会减少不必要的因为超出的原因产生的扩容操作,减少了性能的消耗。
get方法:
/** * 当键为空的时候,就遍历桶,然后找出键为空对应的值。 * 如果键不为空,就通过键生成hash值,再通过hash值生成下标索引,遍历下标索引对应的Entry单链表,获取到hash值和键相同的对应的元素 * 如果查询到的Entry为null那么就返回null,否则返回Entry对应的值。 */ public V get(Object key) { if (key == null) return getForNullKey(); Entry<K,V> entry = getEntry(key); return null == entry ? null : entry.getValue(); } /** * Returns the entry associated with the specified key in the * HashMap. Returns null if the HashMap contains no mapping * for the 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; }
9.巧妙的设计
<1>.通过的表长为2的n次幂<2>.可以通过键获取hash值(hash方法)
<3>.可以通过hash值来获取下标索引(indexFor方法)
<4>.通过下标索引找到对应的Entry值,通过Entry值可以单链表的遍历方式或者hash值方式来找到哪些冲突的值。
<5>.put操作,如果旧空间不够,那么就扩容为原来的2倍,然后将旧元素移动到新空间。
10.参考文章
深入Java集合学习系列:HashMap的实现原理通过分析 JDK 源代码研究 Hash 存储机制
-----------------------------该源码为jdk1.7版本的
相关文章推荐
- java.util.LinkedHashMap源码解析
- java.util.concurrent.ConcurrentHashMap并发哈希表源码解析
- java.util.HashMap源码初探
- 解析java.util集合类源码(Collection和AbstractCollection篇)
- Java HashMap 源码解析
- JDK源码学习(4)-java.util.HashMap、LinkedHashMap与TreeMap
- Java HashMap 源码解析
- java.util.HashMap源码初探
- java WeakHashMap详细介绍(源码解析)和使用示例
- Java中HashMap源码解析
- java.util.HashMap源码要点浅析
- Java源码解析-hashmap
- 解析java.util集合类源码(AbstractList内部类ListIterator和Itr)
- Java HashMap 源码解析
- 散列表:java.util.HashMap源码要点浅析
- 【jdk源码解析三】java.util.Hashtable
- 解析java.util集合类源码(AbstractSequentialList)
- 解析java.util集合类源码(Queue)
- 【转】Java HashMap 源码解析(好文章)
- Java 集合系列10之 HashMap详细介绍(源码解析)和使用示例