[源码分析]HashMap源码分析
工具 :
Inteliji Idea
1. AbstractMap
打开HashMap,你就会发现原来HashMap继承的AbstractMap类,那我们就先来分析下,AbstractMap这个类到底有什么?
下面就是AbstractMap源代码
public abstract class AbstractMap<K,V> implements Map<K,V> { // 获取一个EntrySet,方法是抽象的 public abstract Set<Entry<K,V>> entrySet(); protected AbstractMap() { } // 获取这个EntrySet的大小,也就是HashMap的大小 public int size() { return entrySet().size(); } // 判断hashmap是否为空,判断方法仅判断entrySet的大小 public boolean isEmpty() { return size() == 0; } // 判断hashmap中是否含有value值,循环所有Entry,获取Entry的value // 如果存在相同的值,则返回true public boolean containsValue(Object value) { Iterator<Entry<K,V>> i = entrySet().iterator(); if (value==null) { while (i.hasNext()) { Entry<K,V> e = i.next(); if (e.getValue()==null) return true; } } else { while (i.hasNext()) { Entry<K,V> e = i.next(); if (value.equals(e.getValue())) return true; } } return false; } // 判断hashmap是否存在key,方法和containsValue循环类似。 // 这里注意下,源码中对key和null进行判断,可以返回true,说明hashmap的key可以为null public boolean containsKey(Object key) { Iterator<Map.Entry<K,V>> i = entrySet().iterator(); if (key==null) { while (i.hasNext()) { Entry<K,V> e = i.next(); if (e.getKey()==null) return true; } } else { while (i.hasNext()) { Entry<K,V> e = i.next(); if (key.equals(e.getKey())) return true; } } return false; } // 获取key对应的值,同样也是循环Entryset,如果与key相同,则将值返回 public V get(Object key) { Iterator<Entry<K,V>> i = entrySet().iterator(); if (key==null) { while (i.hasNext()) { Entry<K,V> e = i.next(); if (e.getKey()==null) return e.getValue(); } } else { while (i.hasNext()) { Entry<K,V> e = i.next(); if (key.equals(e.getKey())) return e.getValue(); } } return null; } // 看到这块,我慌了,我记得hashmap是有put方法的,为什么这个直接抛出异常。。 // 看了下这个异常的代码,其实这个错误是说构造函数无详细信息。 // 也就是说,对于AbstractMap类来说,是不能put的 public V put(K key, V value) { throw new UnsupportedOperationException(); } // 根据key删除对应的entry // 处理步骤,首先循环找到key对应的Entry,然后复制给oldValue, 并指定成 null // 所以在网上看到好多说,大量使用hashmap会产生内存泄露,这也是其中一个原因吧。 public V remove(Object key) { Iterator<Entry<K,V>> i = entrySet().iterator(); Entry<K,V> correctEntry = null; if (key==null) { while (correctEntry==null && i.hasNext()) { Entry<K,V> e = i.next(); if (e.getKey()==null) correctEntry = e; } } else { while (correctEntry==null && i.hasNext()) { Entry<K,V> e = i.next(); if (key.equals(e.getKey())) correctEntry = e; } } V oldValue = null; if (correctEntry !=null) { oldValue = correctEntry.getValue(); i.remove(); } return oldValue; } // 将整个Map的值,循环将传入的map // 很奇怪吧,put是会抛出异常的 // 官方注解做了个解释,如果实现类未对put进行支持,那么复制后的map只能是一个空的map public void putAll(Map<? extends K, ? extends V> m) { for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) put(e.getKey(), e.getValue()); } // 清空所有的值 public void clear() { entrySet().clear(); } //keyset values transient volatile Set<K> keySet; transient volatile Collection<V> values; // 判断是否创建了keyset 和 values ,如果不存在则创建。 public Set<K> keySet() { if (keySet == null) { keySet = new AbstractSet<K>() { public Iterator<K> iterator() { return new Iterator<K>() { private Iterator<Entry<K,V>> i = entrySet().iterator(); public boolean hasNext() { return i.hasNext(); } public K next() { return i.next().getKey(); } public void remove() { i.remove(); } }; } public int size() { return AbstractMap.this.size(); } public boolean isEmpty() { return AbstractMap.this.isEmpty(); } public void clear() { AbstractMap.this.clear(); } public boolean contains(Object k) { return AbstractMap.this.containsKey(k); } }; } return keySet; } public Collection<V> values() { if (values == null) { values = new AbstractCollection<V>() { public Iterator<V> iterator() { return new Iterator<V>() { private Iterator<Entry<K,V>> i = entrySet().iterator(); public boolean hasNext() { return i.hasNext(); } public V next() { return i.next().getValue(); } public void remove() { i.remove(); } }; } public int size() { return AbstractMap.this.size(); } public boolean isEmpty() { return AbstractMap.this.isEmpty(); } public void clear() { AbstractMap.this.clear(); } public boolean contains(Object v) { return AbstractMap.this.containsValue(v); } }; } return values; } // 判断是否相等,这个基本功,应该能看懂 public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Map)) return false; Map<?,?> m = (Map<?,?>) o; if (m.size() != size()) return false; try { Iterator<Entry<K,V>> i = entrySet().iterator(); while (i.hasNext()) { Entry<K,V> e = i.next(); K key = e.getKey(); V value = e.getValue(); if (value == null) { if (!(m.get(key)==null && m.containsKey(key))) return false; } else { if (!value.equals(m.get(key))) return false; } } } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } return true; } // Object的方法,至于为什么实现这个,我还是说一下吧 // 首先 hashcode 是用于判断是否相等的,很多人会问有equals为什么用hashcode,而且也没见过这样用的,是的 // 一般来说,equals 是给开发者用来判断两个对象是否相等 // hashcode可以简单的理解为对象的一个码,hashmap 在实现的过程中key 是不可以重复的 // 所以如果两个对象的hashcode相等,那说明这个key就重复了 public int hashCode() { int h = 0; Iterator<Entry<K,V>> i = entrySet().iterator(); while (i.hasNext()) h += i.next().hashCode(); return h; } public String toString() { Iterator<Entry<K,V>> i = entrySet().iterator(); if (! i.hasNext()) return "{}"; StringBuilder sb = new StringBuilder(); sb.append('{'); for (;;) { Entry<K,V> e = i.next(); K key = e.getKey(); V value = e.getValue(); sb.append(key == this ? "(this Map)" : key); sb.append('='); sb.append(value == this ? "(this Map)" : value); if (! i.hasNext()) return sb.append('}').toString(); sb.append(',').append(' '); } } protected Object clone() throws CloneNotSupportedException { AbstractMap<?,?> result = (AbstractMap<?,?>)super.clone(); result.keySet = null; result.values = null; return result; } private static boolean eq(Object o1, Object o2) { return o1 == null ? o2 == null : o1.equals(o2); } public static class SimpleEntry<K,V> implements Entry<K,V>, java.io.Serializable { private static final long serialVersionUID = -8499721149061103585L; private final K key; private V value; public SimpleEntry(K key, V value) { this.key = key; this.value = value; } public SimpleEntry(Entry<? extends K, ? extends V> entry) { this.key = entry.getKey(); this.value = entry.getValue(); } public K getKey() { return key; } public V getValue() { return value; } public V setValue(V value) { V oldValue = this.value; this.value = value; return oldValue; } public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<?,?> e = (Map.Entry<?,?>)o; return eq(key, e.getKey()) && eq(value, e.getValue()); } public int hashCode() { return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode()); } public String toString() { return key + "=" + value; } } // 这里实现了一个Entry对象 public static class SimpleImmutableEntry<K,V> implements Entry<K,V>, java.io.Serializable { private static final long serialVersionUID = 7138329143949025153L; private final K key; private final V value; public SimpleImmutableEntry(K key, V value) { this.key = key; this.value = value; } public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) { this.key = entry.getKey(); this.value = entry.getValue(); } public K getKey() { return key; } public V getValue() { return value; } public V setValue(V value) { throw new UnsupportedOperationException(); } public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<?,?> e = (Map.Entry<?,?>)o; return eq(key, e.getKey()) && eq(value, e.getValue()); } public int hashCode() { return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode()); } public String toString() { return key + "=" + value; } } }
2. 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); this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity); } public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; } public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }
initialCapacity - 初始容量
loadFactor - 装载因子
- 构造函数中 putMapEntries 方法
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) { // 需要复制的原数组大小 int s = m.size(); // 如果原数组不是空的,我们才会进行复制 if (s > 0) { // hashmap中的存储结构是table // table的定义 transient Node<K,V>[] table; if (table == null) { // 计算下次重新初始化的table大小 float ft = ((float)s / loadFactor) + 1.0F; int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); if (t > threshold) threshold = tableSizeFor(t); // 判断如果当前重新生成table大小小于当前的map则直接重新生成table } else if (s > threshold) resize(); for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { K key = e.getKey(); V value = e.getValue(); putVal(hash(key), key, value, false, evict); } } }
-
tableSizeFor 方法
这个方法设计用来,保证容量是2的倍数。不知道为什么这么设计,感觉这块只是为了浪费空间....
static final int tableSizeFor(int cap) { int n = cap - 1; n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }
- resize 方法【初始化和扩容都走这个方法】
final Node<K,V>[] resize() { // 将旧的table复制给oldTab Node<K,V>[] oldTab = table; // 获取旧的table的长度 int oldCap = (oldTab == null) ? 0 : oldTab.length; // 获取旧的table的阈值 int oldThr = threshold; // 初始化新的table的长度和阈值 int newCap, newThr = 0; // 判断旧的table对象是否为空 if (oldCap > 0) { // 如果旧的table已经到达极限,则不能继续扩容了,直接返回原对象(最大长度 1 << 30) if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; // 判断 旧的table大小的2倍,如果还在默认值 和 最大值之间,则将阈值设置成当前阈值的2倍 } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold // 如果旧的table长度为0,但是阈值已经设置(new hashmap()但是没有初始化的情况)新的table长度就是阈值大小 } else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { // zero initial threshold signifies using defaults // 其他情况 则默认设置 newCap = DEFAULT_INITIAL_CAPACITY; // 阈值则是 装载因子 和 初始容量的积 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } // 如果新的阈值为0 ,那么重新分配阈值 if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } // 将新的阈值设置给threshold threshold = newThr; // 下面就开始初始化table了 @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; // 将旧的table中的东西,复制到新的对象中 if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; if (e.next == null) newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
- putVal (map中的put方法给)
// 这个方法就是hashmap的put方法 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; // 判断如果 table 长度为空 直接调用resize方法 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // 在hash表中获取位置,如果该位置是空的,直接添加Node if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { // 如果hash表中的位置存在Node 比较 hash key Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { // 如果不是同一个key ,那么在当前的节点向后延伸(这块是链表结构) for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } // modCount为HashMap的一个实例变量,并且被声明为volatile ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }
下面说一下hashmap的一些机制
Fail-Fast机制
modCount为HashMap的一个实例变量,并且被声明为volatile,表示任何线程都可以看到该变量被其它线程修改的结果(根据JVM内存模型的优化,每一个线程都会存一份自己的工作内存,此工作内存的内容与本地内存并非时时刻刻都同步,因此可能会出现线程间的修改不可见的问题) 。使用Iterator开始迭代时,会将modCount的赋值给expectedModCount,在迭代过程中,通过每次比较两者是否相等来判断HashMap是否在内部或被其它线程修改。HashMap的大多数修改方法都会改ModCount
使用方法
Entry<K,V> nextEntry() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }
好了,hashmap源码分析到此为止,如有意见请联系我,或者留言
还有以下参考资料提供给大家
转载请注明来源