- 各种集合类继承关系
hashMap put原理
-
首先写个测试方法, 初始化size为2，put几个值，再get查询，debug看方法里执行了什么
HashMap<Integer, String> hashMap = new HashMap<>(2); hashMap.put(1, "aaaPh1"); hashMap.put(2, "aaaPh2"); hashMap.put(3, "aaaPh3"); hashMap.put(4, "aaaPh4"); hashMap.put(5, "aaaPh5"); hashMap.put(17, "aaaPh17"); String value = hashMap.get(17); System.out.println(value); -
debug看put方法代码
/** * Associates the specified value with the specified key in this map. * If the map previously contained a mapping for the key, the old * value is replaced. * * @param key key with which the specified value is to be associated * @param value value to be associated with the specified key * @return the previous value associated with {@code key}, or * {@code null} if there was no mapping for {@code key}. * (A {@code null} return can also indicate that the map * previously associated {@code null} with {@code key}.) */ public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } /** * Implements Map.put and related methods. * * @param hash hash for key * @param key the key * @param value the value to put * @param onlyIfAbsent if true, don't change existing value * @param evict if false, the table is in creation mode. * @return previous value, or null if none */ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { 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 { 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; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; } -
首先会执行resize方法初始化hashMap，resize也是hashMap里重要的方法，看一下resize的源代码
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) { if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } 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); } if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; 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; } -
由于是第一次初始化，resize会直接执行到
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; -
如果table不为空，resize会继续往下走，将老的table复制到新的table，这部分的计算很耗时，所以最好第一次就能把预估使用的空间申请好
-
继续往下走，如果hash完所在的单元格有值，则会以链表的形式挂在第一个值后面，解决hash碰撞问题。等到挂了8个后，则会转为B+树。
-
如果当前的节点数达到了最大节点，则会resize，扩展hashMap的大小，并将数据重新复制到新的table里
hashMap get原理
先上源码
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods.
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
我们看到其实查询也很简单，首先通过hash定位到table对应的坑位，通过hash判断是否是目标对象，如果不是，那么看链表或者树里是否有目标值，都没找到的话，返回null
几个关键问题
- 为什么resizse是2的次方
- 只有在特定情况下，位运算才可以转换成取模运算（当 b = 2^n 时，a % b = a & (b - 1) ）。也是因此，HashMap 才将初始长度设置为 16，且扩容只能是以 2 的次方（2^n）扩容
- loadFact为什么是0.75
- hashSet内部使用hashMap，将值存入key中，实现存储对象不重复
- hashmap为什么线程不安全
- Hashtable和HashMap的区别
- *Hashtable：线程安全，效率低。不允许null键和null值 *
- *HashMap：线程不安全，效率高。允许null键和null值*
- List,Set,Map等接口是否都是继承自Map接口?
- * List,Set不是继承自Map接口,他们继承自Collection接口。 *
- 而Map接口本身就是一个顶层接口
43万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
