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，如果超过，进行扩容。