public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable |
HashMap的底层(JDK1.7)
transient Node<K,V>[] table; JDK1.8
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE; JDK1.7
HashMap基于数组和链表实现,内部维护着一个数组table,该数组保存着每个链表的表头结点;查找时,先通过hash函数计算key的hash值,再根据key的hash值计算数组索引(取余法),然后根据索引找到链表表头结点,然后遍历查找该链表。
左边的数组索引是根据key的hash值计算得到,不同hash值有可能产生一样的索引,即哈希冲突,此时采用链地址法处理哈希冲突,即将所有索引一致的节点构成一个单链表
HashMap存取实现
1. public V put(K key, V value) { 2. // HashMap允许存放null键和null值。 3. // 当key为null时,调用putForNullKey方法,将value放置在数组第一个位置。 4. if (key == null) 5. return putForNullKey(value); 6. // 根据key的keyCode重新计算hash值。 7. int hash = hash(key.hashCode()); 8. // 搜索指定hash值在对应table中的索引。 9. int i = indexFor(hash, table.length); 10. // 如果 i 索引处的 Entry 不为 null,通过循环不断遍历 e 元素的下一个元素。 11. for (Entry<K,V> e = table[i]; e != null; e = e.next) { 12. Object k; 13. if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { 14. V oldValue = e.value; 15. e.value = value; 16. e.recordAccess(this); 17. return oldValue; 18. } 19. } 20. // 如果i索引处的Entry为null,表明此处还没有Entry。 21. modCount++; 22. // 将key、value添加到i索引处。 23. addEntry(hash, key, value, i); 24. return null; 25. }
|
当我们往HashMap中put元素的时候,先根据key的hashCode重新计算hash值,根据hash值得到这个元素在数组中的位置(即下标),如果数组该位置上已经存放有其他元素了,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放在链尾。如果数组该位置上没有元素,就直接将该元素放到此数组中的该位置上,调用addEntry方法。 |
|
addEntry(hash, key, value, i)方法根据计算出的hash值,将key-value对放在数组table的i索引处。addEntry 是HashMap 提供的一个包访问权限的方法 |
1. void addEntry(int hash, K key, V value, int bucketIndex) { 2. // 获取指定 bucketIndex 索引处的 Entry 3. Entry<K,V> e = table[bucketIndex]; 4. // 将新创建的 Entry 放入 bucketIndex 索引处,并让新的 Entry 指向原来的 Entry 5. table[bucketIndex] = new Entry<K,V>(hash, key, value, e); 6. // 如果 Map 中的 key-value 对的数量超过了极限 7. if (size++ >= threshold) 8. // 把 table 对象的长度扩充到原来的2倍。 9. resize(2 * table.length); 10. }
|
当系统决定存储HashMap中的key-value对时,完全没有考虑Entry中的value,仅仅只是根据key来计算并决定每个Entry的存储位置。我们完全可以把 Map 集合中的 value 当成 key 的附属,当系统决定了 key 的存储位置之后,value 随之保存在那里即可 |
在HashMap中要找到某个元素,需要根据key的hash值来求得对应数组中的位置。如何计算这个位置就是hash算法。前面说过HashMap的数据结构是数组和链表的结合,所以我们当然希望这个HashMap里面的元素位置尽量的分布均匀些,尽量使得每个位置上的元素数量只有一个,那么当我们用hash算法求得这个位置的时候,马上就可以知道对应位置的元素就是我们要的,而不用再去遍历链表,这样就大大优化了查询的效率。
对于任意给定的对象,只要它的 hashCode() 返回值相同,那么程序调用 hash(int h) 方法所计算得到的 hash 码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算,这样一来,元素的分布相对来说是比较均匀的。但是,“模”运算的消耗还是比较大的,在HashMap中是这样做的:调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处
查找时先通过get()方法,然后再getEntry(),在getEntry方法中调用indexFor方法
static int indexFor(int h, int length) { return h & (length-1); }
|
这个方法非常巧妙,它通过 h & (table.length -1) 来得到该对象的保存位,而HashMap底层数组的长度总是 2 的n 次方,这是HashMap在速度上的优化 |
当length总是 2 的n次方时,h& (length-1)运算等价于对length取模,也就是h%length,但是&比%具有更高的效率 |
解释h&(length-1)
假设数组长度分别为15和16,优化后的hash码分别为8和9,那么&运算后的结果如下:
h & (table.length-1) hash table.length-1
8&(15-1): 0100 & 1110 = 0100
9&(15-1): 0101 & 1110 = 0100
----------------------------------------------------------------------------------------------------------------
8 & (16-1): 0100 & 1111 = 0100
9 & (16-1): 0101 & 1111 = 0101
&是与运算符,要进行二进制化的操作
当它们和15-1(1110)“与”的时候,产生了相同的结果,也就是说它们会定位到数组中的同一个位置上去,这就产生了碰撞,8和9会被放到数组中的同一个位置上形成链表,那么查询的时候就需要遍历这个链 表,得到8或者9,这样就降低了查询的效率。同时,我们也可以发现,当数组长度为15的时候,hash值会与15-1(1110)进行“与”,那么 最后一位永远是0,而0001,0011,0101,1001,1011,0111,1101这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!而当数组长度为16时,即为2的n次方时,2n-1得到的二进制数的每个位上的值都为1,这使得在低位上&时,得到的和原hash的低位相同,加之hash(int h)方法对key的hashCode的进一步优化,加入了高位计算,就使得只有相同的hash值的两个值才会被放到数组中的同一个位置上形成链表。
所以说,当数组长度为2的n次幂的时候,不同的key算得得index相同的几率较小,那么数据在数组上分布就比较均匀,也就是说碰撞的几率小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就高了
重点:HashMap的扩容,即resize
当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,数组扩容这个操作也会出现在ArrayList中,这是一个常用的操作,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。
那么HashMap什么时候进行扩容呢?
当HashMap中的元素个数超过数组大小*loadFactor时,就会进行数组扩容,loadFactor的默认值为0.75,这是一个折中的取值。也就是说,默认情况下,数组大小为16,那么当HashMap中元素个数超过16*0.75=12的时候,就把数组的大小扩展为 2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。
loadFactor:负载因子loadFactor定义为:散列表的实际元素数目(n)/ 散列表的容量(m) final float loadFactor; 负载因子衡量的是一个散列表的空间的使用程度,负载因子越大表示散列表的装填程度越高,反之愈小。对于使用链表法的散列表来说,查找一个元素的平均时间是O(1+a),因此如果负载因子越大,对空间的利用更充分,然而后果是查找效率的降低;如果负载因子太小,那么散列表的数据将过于稀疏,对空间造成严重浪费 |
Fail-Fast机制,并发迭代时出现
我们知道java.util.HashMap不是线程安全的,因此如果在使用迭代器的过程中有其他线程修改了map,那么将抛出ConcurrentModificationException,这就是所谓fail-fast策略。
这一策略在源码中的实现是通过modCount域,modCount顾名思义就是修改次数,对HashMap内容的修改都将增加这个值,那么在迭代器初始化过程中会将这个值赋给
迭代器的expectedModCount。
HashIterator() { expectedModCount = modCount; if (size > 0) { // advance to first entry Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } }
|
modCount声明为volatile,保证线程之间修改的可见性
在迭代过程中,判断modCount跟expectedModCount是否相等,如果不相等就表示已经有其他线程修改了Map
1. final Entry<K,V> nextEntry() { 2. if (modCount != expectedModCount) 3. throw new ConcurrentModificationException();
|
HashMap和LinkedHashMap
LinkedHashMap:LinkedHashMap是HashMap的一个子类,保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的,也可以在构造时带参数,按照访问次序排序
附JDK1.7的源码分析:
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
/** * 默认初始容量,默认为2的4次方 = 16,2的n次方是为了加快hash计算速度,;;减少hash冲突,,,h & (length-1),,1111111 */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/** * 最大容量,默认为2的30次方, */ static final int MAXIMUM_CAPACITY = 1 << 30;
/** * 默认负载因子,默认为0.75 */ static final float DEFAULT_LOAD_FACTOR = 0.75f;
/** *当数组表还没扩容的时候,一个共享的空表对象 */ static final Entry<?,?>[] EMPTY_TABLE = {};
/** * 数组表,大小可以改变,且大小必须为2的幂 */ transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
/** * 当前Map中key-value映射的个数 */ transient int size;
/** * 下次扩容阈值,当size > capacity * load factor时,开始扩容 */ int threshold;
/** * 负载因子 */ final float loadFactor;
/** * Hash表结构性修改次数,用于实现迭代器快速失败行为 */ transient int modCount;
/** * 容量阈值,默认大小为Integer.MAX_VALUE */ static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
/** * 静态内部类Holder,存放一些只能在虚拟机启动后才能初始化的值 */ private static class Holder {
/** * 容量阈值,初始化hashSeed的时候会用到该值 */ static final int ALTERNATIVE_HASHING_THRESHOLD;
static { //获取系统变量jdk.map.althashing.threshold String altThreshold = java.security.AccessController.doPrivileged( new sun.security.action.GetPropertyAction( "jdk.map.althashing.threshold"));
int threshold; try { threshold = (null != altThreshold) ? Integer.parseInt(altThreshold) : ALTERNATIVE_HASHING_THRESHOLD_DEFAULT;
// jdk.map.althashing.threshold系统变量默认为-1,如果为-1,则将阈值设为Integer.MAX_VALUE if (threshold == -1) { threshold = Integer.MAX_VALUE; } //阈值需要为正数 if (threshold < 0) { throw new IllegalArgumentException("value must be positive integer."); } } catch(IllegalArgumentException failed) { throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed); }
ALTERNATIVE_HASHING_THRESHOLD = threshold; } }
/** * 计算hash值的时候需要用到 */ transient int hashSeed = 0;
/** * 生成一个空的HashMap,并指定其容量大小和负载因子 * */ public HashMap(int initialCapacity, float loadFactor) { //保证初始容量大于等于0 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); //保证初始容量不大于最大容量MAXIMUM_CAPACITY if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY;
//loadFactor小于0或为无效数字 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); //负载因子 this.loadFactor = loadFactor; //下次扩容大小 threshold = initialCapacity; init(); }
/** * 生成一个空的HashMap,并指定其容量大小,负载因子使用默认的0.75 * */ public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
/** * 生成一个空的HashMap,容量大小使用默认值16,负载因子使用默认值0.75 */ public HashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); }
/** * 根据指定的map生成一个新的HashMap,负载因子使用默认值,初始容量大小为Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,DEFAULT_INITIAL_CAPACITY) */ public HashMap(Map<? extends K, ? extends V> m) { this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR); inflateTable(threshold);
putAllForCreate(m); }
//返回>=number的最小2的n次方值,如number=5,则返回8 private static int roundUpToPowerOf2(int number) { // assert number >= 0 : "number must be non-negative"; return number >= MAXIMUM_CAPACITY ? MAXIMUM_CAPACITY : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1; }
/** * 对table扩容 */ private void inflateTable(int toSize) { // Find a power of 2 >= toSize //找一个值(2的n次方,且>=toSize) int capacity = roundUpToPowerOf2(toSize);
//下次扩容阈值 threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity]; initHashSeedAsNeeded(capacity); }
// internal utilities
void init() { }
/** * 初始化hashSeed */ final boolean initHashSeedAsNeeded(int capacity) { boolean currentAltHashing = hashSeed != 0; boolean useAltHashing = sun.misc.VM.isBooted() && (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD); boolean switching = currentAltHashing ^ useAltHashing; if (switching) { hashSeed = useAltHashing ? sun.misc.Hashing.randomHashSeed(this) : 0; } return switching; }
/** * 生成hash值 */ final int hash(Object k) { int h = hashSeed;
//如果key是字符串,调用un.misc.Hashing.stringHash32生成hash值 //Oracle表示能生成更好的hash分布,不过这在jdk8中已删除 if (0 != h && k instanceof String) { return sun.misc.Hashing.stringHash32((String) k); } //一次散列,调用k的hashCode方法,与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). //二次散列, h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }
/** * 返回hash值的索引,采用除模取余法,h & (length-1)操作 等价于 hash % length操作, 但&操作性能更优 */ static int indexFor(int h, int length) { // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2"; return h & (length-1); }
/** * 返回key-value映射个数 */ public int size() { return size; }
/** * 判断map是否为空 */ public boolean isEmpty() { return size == 0; }
/** * 返回指定key对应的value */ public V get(Object key) { //key为null情况 if (key == null) return getForNullKey();
//根据key查找节点 Entry<K,V> entry = getEntry(key);
//返回key对应的值 return null == entry ? null : entry.getValue(); }
/** * 查找key为null的value,注意如果key为null,则其hash值为0,默认是放在table[0]里的 */ private V getForNullKey() { if (size == 0) { return null; } //在table[0]的链表上查找key为null的键值对,因为null默认是存在table[0]的桶里 for (Entry<K,V> e = table[0]; e != null; e = e.next) { if (e.key == null) return e.value; } return null; }
/** *判断是否包含指定的key */ public boolean containsKey(Object key) { return getEntry(key) != null; }
/** * 根据key查找键值对,找不到返回null */ final Entry<K,V> getEntry(Object key) { if (size == 0) { return null; } //如果key为null,hash值为0,否则调用hash方法,对key生成hash值 int hash = (key == null) ? 0 : hash(key);
//调用indexFor方法生成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; }
/** * 向map存入一个键值对,如果key已存在,则覆盖 */ public V put(K key, V value) { //数组为空,对数组扩容 if (table == EMPTY_TABLE) { inflateTable(threshold); }
//对key为null的键值对调用putForNullKey处理 if (key == null) return putForNullKey(value);
//生成hash值 int hash = hash(key);
//生成hash值索引 int i = indexFor(hash, table.length);
//查找是否有key“相等”的键值对,有的话覆盖 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++;
//在指定hash值索引处的链表上增加该键值对 addEntry(hash, key, value, i); return null; }
/** * 存放key为null的键值对,存放在索引为0的链表上,已存在的话,替换 */ private V putForNullKey(V value) { for (Entry<K,V> e = table[0]; e != null; e = e.next) { //已存在key为null,则替换 if (e.key == null) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } //操作次数加一,用于迭代器快速失败行为 modCount++; //在指定hash值索引处的链表上增加该键值对 addEntry(0, null, value, 0); return null; }
/** * 添加键值对 */ private void putForCreate(K key, V value) { //生成hash值 int hash = null == key ? 0 : hash(key);
//生成hash值索引, int i = indexFor(hash, table.length);
/** * key“相等”,则替换 */ 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(hash, key, value, i); }
//将制定map的键值对添加到map中 private void putAllForCreate(Map<? extends K, ? extends V> m) { for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) putForCreate(e.getKey(), e.getValue()); }
/** * 对数组扩容 */ 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];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
//table索引替换成新数组 table = newTable;
//重新计算阈值 threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); }
/** * 拷贝旧的键值对到新的哈希表中 */ void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; //遍历旧的数组 for (Entry<K,V> e : table) { while(null != e) { Entry<K,V> next = e.next; if (rehash) { e.hash = null == e.key ? 0 : hash(e.key); } //根据新的数组长度,重新计算索引, int i = indexFor(e.hash, newCapacity);
//插入到链表表头 e.next = newTable[i];
//将e放到索引为i处 newTable[i] = e;
//将e设置成下个节点 e = next; } } }
/** * 将制定map的键值对put到本map,key“相等”的直接覆盖 */ public void putAll(Map<? extends K, ? extends V> m) { int numKeysToBeAdded = m.size(); if (numKeysToBeAdded == 0) return;
//空map,扩容 if (table == EMPTY_TABLE) { inflateTable((int) Math.max(numKeysToBeAdded * loadFactor, threshold)); }
/* * 判断是否需要扩容 */ if (numKeysToBeAdded > threshold) { int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1); if (targetCapacity > MAXIMUM_CAPACITY) targetCapacity = MAXIMUM_CAPACITY; int newCapacity = table.length; while (newCapacity < targetCapacity) newCapacity <<= 1; if (newCapacity > table.length) resize(newCapacity); }
//依次遍历键值对,并put for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) put(e.getKey(), e.getValue()); }
/** * 移除指定key的键值对 */ public V remove(Object key) { Entry<K,V> e = removeEntryForKey(key); return (e == null ? null : e.value); }
/** * 移除指定key的键值对 */ final Entry<K,V> removeEntryForKey(Object key) { if (size == 0) { return null; } //计算hash值及索引 int hash = (key == null) ? 0 : hash(key); int i = indexFor(hash, table.length);
Entry<K,V> prev = table[i]; Entry<K,V> e = prev;
//头节点为table[i]的单链表上执行删除节点操作 while (e != null) { Entry<K,V> next = e.next; Object k; //找到要删除的节点 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { modCount++; size--; if (prev == e) table[i] = next; else prev.next = next; e.recordRemoval(this); return e; } prev = e; e = next; }
return e; }
/** * 删除指定键值对对象(Entry对象) */ final Entry<K,V> removeMapping(Object o) { if (size == 0 || !(o instanceof Map.Entry)) return null;
Map.Entry<K,V> entry = (Map.Entry<K,V>) o; Object key = entry.getKey(); int hash = (key == null) ? 0 : hash(key); //得到数组索引 int i = indexFor(hash, table.length); Entry<K,V> prev = table[i]; Entry<K,V> e = prev; //开始遍历该单链表 while (e != null) { Entry<K,V> next = e.next; //找到节点 if (e.hash == hash && e.equals(entry)) { modCount++; size--; if (prev == e) table[i] = next; else prev.next = next; e.recordRemoval(this); return e; } prev = e; e = next; }
return e; }
/** * 清空map,将table数组所有元素设为null */ public void clear() { modCount++; Arrays.fill(table, null); size = 0; }
/** * 判断是否含有指定value的键值对 */ public boolean containsValue(Object value) { if (value == null) return containsNullValue();
Entry[] tab = table; //遍历table数组 for (int i = 0; i < tab.length ; i++) //遍历每条单链表 for (Entry e = tab[i] ; e != null ; e = e.next) if (value.equals(e.value)) return true; return false; }
/** * 判断是否含有value为null的键值对 */ private boolean containsNullValue() { Entry[] tab = table; for (int i = 0; i < tab.length ; i++) for (Entry e = tab[i] ; e != null ; e = e.next) if (e.value == null) return true; return false; }
/** * 浅拷贝,键值对不复制 */ public Object clone() { HashMap<K,V> result = null; try { result = (HashMap<K,V>)super.clone(); } catch (CloneNotSupportedException e) { // assert false; } if (result.table != EMPTY_TABLE) { result.inflateTable(Math.min( (int) Math.min( size * Math.min(1 / loadFactor, 4.0f), // we have limits... HashMap.MAXIMUM_CAPACITY), table.length)); } result.entrySet = null; result.modCount = 0; result.size = 0; result.init(); result.putAllForCreate(this);
return result; }
//内部类,节点对象,每个节点包含下个节点的引用 static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next; int hash;
/** * 创建节点 */ Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; } //获取节点的key public final K getKey() { return key; } //获取节点的value public final V getValue() { return value; }
//设置新value,并返回旧的value public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; }
//判断key和value是否相同,两个都“相等”,返回true public final boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry e = (Map.Entry)o; Object k1 = getKey(); Object k2 = e.getKey(); if (k1 == k2 || (k1 != null && k1.equals(k2))) { Object v1 = getValue(); Object v2 = e.getValue(); if (v1 == v2 || (v1 != null && v1.equals(v2))) return true; } return false; }
public final int hashCode() { return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue()); }
public final String toString() { return getKey() + "=" + getValue(); }
/** * This method is invoked whenever the value in an entry is * overwritten by an invocation of put(k,v) for a key k that's already * in the HashMap. */ void recordAccess(HashMap<K,V> m) { }
/** * This method is invoked whenever the entry is * removed from the table. */ void recordRemoval(HashMap<K,V> m) { } }
/** * 添加新节点,如有必要,执行扩容操作 */ void addEntry(int hash, K key, V value, int bucketIndex) { if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length); hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); }
createEntry(hash, key, value, bucketIndex); }
/** * 插入单链表表头 */ void createEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<>(hash, key, value, e); size++; }
//hashmap迭代器 private abstract class HashIterator<E> implements Iterator<E> { Entry<K,V> next; // 下个键值对索引 int expectedModCount; // 用于判断快速失败行为 int index; // current slot Entry<K,V> current; // current entry HashIterator() { expectedModCount = modCount; if (size > 0) { // advance to first entry Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } }
public final boolean hasNext() { return next != null; }
final Entry<K,V> nextEntry() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); Entry<K,V> e = next; if (e == null) throw new NoSuchElementException();
if ((next = e.next) == null) { Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } current = e; return e; }
public void remove() { if (current == null) throw new IllegalStateException(); if (modCount != expectedModCount) throw new ConcurrentModificationException(); Object k = current.key; current = null; HashMap.this.removeEntryForKey(k); expectedModCount = modCount; } }
//ValueIterator迭代器 private final class ValueIterator extends HashIterator<V> { public V next() { return nextEntry().value; } } //KeyIterator迭代器 private final class KeyIterator extends HashIterator<K> { public K next() { return nextEntry().getKey(); } } ////KeyIterator迭代器 private final class EntryIterator extends HashIterator<Map.Entry<K,V>> { public Map.Entry<K,V> next() { return nextEntry(); } }
// 返回迭代器方法 Iterator<K> newKeyIterator() { return new KeyIterator(); } Iterator<V> newValueIterator() { return new ValueIterator(); } Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); }
// Views
private transient Set<Map.Entry<K,V>> entrySet = null;
/** * 返回一个set集合,包含key */ public Set<K> keySet() { Set<K> ks = keySet; return (ks != null ? ks : (keySet = new KeySet())); }
private final class KeySet extends AbstractSet<K> { public Iterator<K> iterator() { return newKeyIterator(); } public int size() { return size; } public boolean contains(Object o) { return containsKey(o); } public boolean remove(Object o) { return HashMap.this.removeEntryForKey(o) != null; } public void clear() { HashMap.this.clear(); } }
/** * 返回一个value集合,包含value */ public Collection<V> values() { Collection<V> vs = values; return (vs != null ? vs : (values = new Values())); }
private final class Values extends AbstractCollection<V> { public Iterator<V> iterator() { return newValueIterator(); } public int size() { return size; } public boolean contains(Object o) { return containsValue(o); } public void clear() { HashMap.this.clear(); } }
/** * 返回一个键值对集合 */ public Set<Map.Entry<K,V>> entrySet() { return entrySet0(); }
private Set<Map.Entry<K,V>> entrySet0() { Set<Map.Entry<K,V>> es = entrySet; return es != null ? es : (entrySet = new EntrySet()); }
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> { public Iterator<Map.Entry<K,V>> iterator() { return newEntryIterator(); } public boolean contains(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<K,V> e = (Map.Entry<K,V>) o; Entry<K,V> candidate = getEntry(e.getKey()); return candidate != null && candidate.equals(e); } public boolean remove(Object o) { return removeMapping(o) != null; } public int size() { return size; } public void clear() { HashMap.this.clear(); } }
/** * map序列化,可实现深拷贝 */ private void writeObject(java.io.ObjectOutputStream s) throws IOException { // Write out the threshold, loadfactor, and any hidden stuff s.defaultWriteObject();
// Write out number of buckets if (table==EMPTY_TABLE) { s.writeInt(roundUpToPowerOf2(threshold)); } else { s.writeInt(table.length); }
// Write out size (number of Mappings) s.writeInt(size);
// Write out keys and values (alternating) if (size > 0) { for(Map.Entry<K,V> e : entrySet0()) { s.writeObject(e.getKey()); s.writeObject(e.getValue()); } } }
private static final long serialVersionUID = 362498820763181265L;
/** * 反序列化,读取字节码转为对象 */ private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { // Read in the threshold (ignored), loadfactor, and any hidden stuff s.defaultReadObject(); if (loadFactor <= 0 || Float.isNaN(loadFactor)) { throw new InvalidObjectException("Illegal load factor: " + loadFactor); }
// set other fields that need values table = (Entry<K,V>[]) EMPTY_TABLE;
// Read in number of buckets s.readInt(); // ignored.
// Read number of mappings int mappings = s.readInt(); if (mappings < 0) throw new InvalidObjectException("Illegal mappings count: " + mappings);
// capacity chosen by number of mappings and desired load (if >= 0.25) int capacity = (int) Math.min( mappings * Math.min(1 / loadFactor, 4.0f), // we have limits... HashMap.MAXIMUM_CAPACITY);
// allocate the bucket array; if (mappings > 0) { inflateTable(capacity); } else { threshold = capacity; }
init(); // Give subclass a chance to do its thing.
// Read the keys and values, and put the mappings in the HashMap for (int i = 0; i < mappings; i++) { K key = (K) s.readObject(); V value = (V) s.readObject(); putForCreate(key, value); } }
|
JDK1.7与JDK1.8的比较和区别:
JDK1.7中
使用一个Entry数组来存储数据,用key的hashcode取模来决定key会被放到数组里的位置,如果hashcode相同,或者hashcode取模后的结果相同(hash collision),那么这些key会被定位到Entry数组的同一个格子里,这些key会形成一个链表。
在hashcode特别差的情况下,比方说所有key的hashcode都相同,这个链表可能会很长,那么put/get操作都可能需要遍历这个链表
也就是说时间复杂度在最差情况下会退化到O(n)
JDK1.8中
使用一个Node数组来存储数据,但这个Node可能是链表结构,也可能是红黑树结构
如果插入的key的hashcode相同,那么这些key也会被定位到Node数组的同一个格子里。
如果同一个格子里的key不超过8个,使用链表结构存储。
如果超过了8个,那么会调用treeifyBin函数,将链表转换为红黑树。
那么即使hashcode完全相同,由于红黑树的特点,查找某个特定元素,也只需要O(log n)的开销,也就是说put/get的操作的时间复杂度最差只有O(log n)
1.8中的限制
听起来挺不错,但是真正想要利用JDK1.8的好处,有一个限制:
key的对象,必须正确的实现了Compare接口
如果没有实现Compare接口,或者实现得不正确(比方说所有Compare方法都返回0)
那JDK1.8的HashMap其实还是慢于JDK1.7的
避免Hash Collision DoS攻击
Java中String的hashcode函数的强度很弱,有心人可以很容易的构造出大量hashcode相同的String对象。
如果向服务器一次提交数万个hashcode相同的字符串参数,那么可以很容易的卡死JDK1.7版本的服务器。
但是String正确的实现了Compare接口,因此在JDK1.8版本的服务器上,Hash Collision DoS不会造成不可承受的开销。
HashMap:它根据键的hashCode值存储数据,大多数情况下可以直接定位到它的值,因而具有很快的访问速度,但遍历顺序却是不确定的。 HashMap最多只允许一条记录的键为null,允许多条记录的值为null。HashMap非线程安全,即任一时刻可以有多个线程同时写HashMap,可能会导致数据的不一致。如果需要满足线程安全,可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力,或者使用ConcurrentHashMap
JDK1.8的HashMap实现
HashMap是数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的
而当链表长度太长(默认超过8)时,链表就转换为红黑树,利用红黑树快速增删改查的特点提高HashMap的性能
Node[] table,即哈希桶数组
static class Node<K,V> implements Map.Entry<K,V> { final int hash;//用来定义数组的索引位置 final K key; V value; Node<K,V> next;//下一个node
Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } } |
Node是HashMap的一个内部类,实现了Map.Entry接口,本质是就是一个映射(键值对)。上图中的每个黑色圆点就是一个Node对象
|
HashMap的put方法
①.判断键值对数组table[i]是否为空或为null,否则执行resize()进行扩容;
②.根据键值key计算hash值得到插入的数组索引i,如果table[i]==null,直接新建节点添加,转向⑥,如果table[i]不为空,转向③;
③.判断table[i]的首个元素是否和key一样,如果相同直接覆盖value,否则转向④,这里的相同指的是hashCode以及equals;
④.判断table[i] 是否为treeNode,即table[i] 是否是红黑树,如果是红黑树,则直接在树中插入键值对,否则转向⑤;
⑤.遍历table[i],判断链表长度是否大于8,大于8的话把链表转换为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;
⑥.插入成功后,判断实际存在的键值对数量size是否超多了最大容量threshold,如果超过,进行扩容。