JAVA 集合类(java.util)源码阅读笔记------HashMap
来源:互联网 发布:淘宝模特媛媛 编辑:程序博客网 时间:2024/06/01 08:26
一、继承关系
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
cloneable接口:重写OBject的clone方法。
Serializable接口:该类可序列化
二、成员变量
transient Node<K,V>[] table;//hash表的桶,用一个数组模拟,数组中每个元素都是一个指针,要么是单链表的头指针,要么是红黑树的根节点的指针transient Set<Map.Entry<K,V>> entrySet; //用来实现遍历map的set,依次遍历table中所有桶中的node或者treeNodetransient int size;//该map中所有key-value对的个数,node的个数transient int modCount;//修改次数,用来判断是否该map同时被多个线程操作,多线程环境下会抛出异常ConcurrentModificationException。int threshold;//= table.size()* loadFactor,当table中实际占用量(不是table中占用的bin的个数,而是所有bin中的Nodede 总数)超过threshold时,就会进行resize()操作//eg:table.size()=16,loadFactor=0.75,则当所有Bin中的node的个数超过12时会进行resize.//table的容量,如果没有设置,则默认等于DEFAULT_INITIAL_CAPACITY=16,且必须为2的整数次幂。final float loadFactor;//加载因子<=1,当table中实际占用的容量超过table.size()* loadFactor时,会进行table的扩容。默认加载因子为DEFAULT_LOAD_FACTOR=0.75static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //table默认初始容量 16,必须是2的整数次幂static final int MAXIMUM_CAPACITY = 1 << 30;//table的最大容量static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因子,当table数组的容量超过table.length* loadFactor时,会调用resize()进行扩容。static final int TREEIFY_THRESHOLD = 8;//当table[i]中的node个数超过8个,会将单链表table[i]转化成红黑树static final int UNTREEIFY_THRESHOLD = 6;//当table[i]中红黑树的节点数少于6时,会退化成单链表static final int MIN_TREEIFY_CAPACITY = 64;//当table的length大于64时,才会进行将某条node个数超过8的单链表转化成红黑树操作
三、方法说明
1、构造方法
只会设置加载因子和threshold,不会初始化table数组,数组的初始化在第一个add时调用resize()方法进行)
public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);//设置的初始容量大于最大允许容量,则强制将initialCapacity = MAXIMUM_CAPACITY if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor;//调用tableSizeFor将threshold设置成大于initialCapacity的最小的2的整数次幂 this.threshold = tableSizeFor(initialCapacity); } public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }
2、重要方法
(1)hash:根据每个Node的key求hash
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}h >>> 16:循环右移16位,不管符号,高位填0。h 为int型,四个字节,因此右移16位相当于把高两位字节移到最右边,舍弃原先低两位的字节。
通过hash值取对应的桶序号的方法:
h & (table.length -1)(h是调用hash()返回的值)相当于对table取余,保证所有的value的hash通过运算最终都落在0-table.size()-1之间。
它通过h & (table.length -1)来得到该对象的保存位,而HashMap底层数组的长度总是2的n次方,这是HashMap在速度上的优化。当length总是2的n次方时,h& (length-1)运算等价于对length取模,也就是h%length,但是&比%具有更高的效率。
(2)tableSizeFor
功能:求大于cap的最小的2的整数次方的值,如cap=57,则返回64。保证table的size始终为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;}
(3)resize
总结:
1)若table没有初始化,则采用默认的cap和加载因子(或者使用new map对象时传递进来的thr和f)进行初始化,为table申请空间
2)若table已经初始化,则将cap*2,thr*2。同时若cap已经超过了MAX_CAP,则直接将thr设置与cap相等。
3)将oldTable中的node都映射到newTable中。OldTable[i]中的node要么映射到newTable的i中,要么是i+oldcap中,由node.hash的第oldCap二进制中1所在位置j的那个位置bit值决定。
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table;//cap是数组的容量,thr是数组进行扩容的临界值 int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0;//不是数组初始化 if (oldCap > 0) {//当原table的size已经达到MAXIMUM_CAPACITY时,不对cap进行调整,只是将扩容临界值thr调整为与cap相同,让table空间得到100%的利用 if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; }//否则就将cap和thr进行*2扩容//即使newCap<<1,它的值也始终小于Integer.MAX_VALUE,因为newCap是一个int型的整数 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold }//通过初始化传递了thr但是还没有进行table的初始化操作,这时将cap设置为oldCap的值 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr;//初始化没有传递任何参数,cap和thr都采用默认值 else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); }//如果上面没有设置newThr的值,这里统一进行处理.//主要有两个地方,第一个else if ((newCap = oldCap << 1),第二个else if (oldThr > 0); if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); }//重新设置扩容后的临界值 threshold = newThr;//利用上面计算的newCap重新为数组申请扩容后的空间 @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab;//将原数组中内容转移到新数组中 if (oldTab != null) {//原table中每个桶中的node逐个进行重新hash处理 for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) {//将原table中每个链表的头指针置null oldTab[j] = null;//如果oldTable[i]这条链表只有头指针,则将该node重新hash映射到新链表的某个位置上 if (e.next == null) newTab[e.hash & (newCap - 1)] = e;//如果该条链表是以红黑树的形式存储的,则调用红黑树的相关操作 else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);//对oldTable[i]链表中每个元素逐一处理 else { // preserve order//lo表示原链表中的node在新链表中的映射仍在同一位置table[i] Node<K,V> loHead = null, loTail = null;//hi 表示原链表中的node在新链表中的映射在table[i+oldCap]。只有这两种位置 Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; //i=e.hash&(oldCap-1),那么e.hash&oldCap的值为e.hash在oldCap二进制形式中那个唯一(cap的值都为2的整数次幂,所以二进制形式中只有一个1)的1所在位置的值,要么为0,要么为1.。//因此,oldTable中的table[i]中的node,在新链表中的位置要么为i,要么为i+oldCap//之所以直接采用(e.hash & oldCap)是为了计算简便,避免每次都用e.hash&(newCap-1)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);//在新table中映射位置为j的,相对顺序与oldTable中的相同 if (loTail != null) { loTail.next = null; newTab[j] = loHead; }//在新链表中映射位置为j+oldCap的 if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
(4)treeifyBin将某个hash桶的单链表转化成红黑树;untreeify将红黑树转化成单链表,在删除红黑树节点时会用到
基本步骤:
a、检查table.length是否>=64,如果不成立,则进行resize扩容,结束。
b、通过hash&(n-1)定位到table相应的bin中,检查bin中是否有Node,将单链表中的Node类型依次转化成treenode类型,并链接在一个双链表中
c、调用treeNode.treeify方法将该桶中的treeNode双链表转化成红黑树。
final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e;//若table的len没有达到最小树化值,则进行扩容处理 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize();//若该桶中有node,则将该桶中的单链表转化成红黑树 else if ((e = tab[index = (n - 1) & hash]) != null) { TreeNode<K,V> hd = null, tl = null; do {//将每个node节点的值重新生成一个TreeNode节点 TreeNode<K,V> p = replacementTreeNode(e, null);hd指向红黑树的根节点 if (tl == null) hd = p; else {//prev指向前一个节点,next指向后一个节点 p.prev = tl; tl.next = p; } tl = p; } while ((e = e.next) != null);//上面的while循环将单链表转化成了双链表,节点类型由node编程了treeNode,hd指向头结点 if ((tab[index] = hd) != null)//将该双链表构建成红黑树 hd.treeify(tab); } }红黑树退化成单链表a、通过treeNode.next遍历红黑树,并将节点依次replacementNode成Node类型。b、将转化后的节点依次链接成一条单链表,返回头结点的指针 final Node<K,V> untreeify(HashMap<K,V> map) { Node<K,V> hd = null, tl = null; for (Node<K,V> q = this; q != null; q = q.next) {//将红黑树中的节点treeNode依次转化成node Node<K,V> p = map.replacementNode(q, null); if (tl == null) hd = p; else tl.next = p; tl = p; }//返回单链表的头结点 return hd; }
(5)remove
public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; }removeNode:删除指定的key所对应的Node,matchValue为true表示只有key和value都对应才删除;movable表示在删除时不移动其他nodefinal Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index;//只有在table不为空,table的length大于0,hash&(n-1)号桶中有值时才进行查找删除 if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v;//如果头结点是查找的节点则令node指向它 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) {//如果这个桶中存储的是红黑树,则通过getTreeNode找到对应的node if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else {//如果是单链表,则依次查找node,知道找到,令node指向它 do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } }//当Node==null表示没有找到该节点//只有当不要求匹配value或者要求匹配并且node的value也相等时,才进行删除 if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) {//在红黑树中删除节点,把movable传递进去 if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);//头结点删除 else if (node == p) tab[index] = node.next;//p指向node的前一个节点 else p.next = node.next; ++modCount; --size;//回调接口,让LinkedHashMap执行对应的动作。在hashMap中没有动作:void afterNodeRemoval(Node<K,V> p) { } afterNodeRemoval(node); return node; } } return null; }
(6)containsValue:遍历整个map查找
treeNode也实现了Node的next功能,因此调用next可以遍历单链表和红黑树
public boolean containsValue(Object value) { Node<K,V>[] tab; V v; if ((tab = table) != null && size > 0) { for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) { if ((v = e.value) == value || (value != null && value.equals(v))) return true; } } } return false; } public boolean containsValue(Object value) { Node<K,V>[] tab; V v; if ((tab = table) != null && size > 0) { for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) { if ((v = e.value) == value || (value != null && value.equals(v))) return true; } } } return false; }
(7)get:获取key对应的node
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k;//table不为空,table.length>0,hash对应的桶中有值 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; }
(8)put:map中插入
1)如果是首个插入map的节点,map进行初始化,在resize中进行
2)如果是put一个新节点,则插入结束后检查对应的bin是否需要转化成红黑树
3)插入或更新结束后,检查该table是否需要resize扩容(有可能插入到一个空桶中,导致table中桶的占用量超过了thr)
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }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为null或者table的长度为0,则调用resize()对table进行初始化 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length;//如果hash&(n-1)号桶中没有node,则将该节点作为首节点放入该桶中 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k;//p为桶的首节点,p为要找的节点,e指向它 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p;//在红黑树中查找,e指向查找到的treeNode else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else {//遍历桶中的节点 for (int binCount = 0; ; ++binCount) {//当遍历该桶没有找到相同的key时,就新new一个Node,加入到桶中 if ((e = p.next) == null) { p.next = newNode(hash, key, value, null);//同时检查该桶中Node的个数是否>=8,是则要将单链表转化成红黑树 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; }//否则在单链表中找到Node的key与给定key相等的节点,e指向它,p指向e的前一个节点 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;//更新Node的value if (!onlyIfAbsent || oldValue == null) e.value = value;//回调接口,让LinkedHashMap执行对应的动作。在hashMap中没有动作:void afterNodeAccess(e); return oldValue; } } ++modCount;//检查table的size有没有超过临界值,超过要进行resize扩容 if (++size > threshold) resize();//回调接口,让LinkedHashMap执行对应的动作。在hashMap中没有动作:void afterNodeInsertion(evict); return null; }
(9)关于entrySet、keySet和values的实现
首先需要知道它们中都要一个迭代器,该iterator继承自同一个Abstract的HashIterator,在该抽象类中,nextNode方法实现了依次遍历table中所有bin中的Node或treeNode节点。后面的KeyIterator、ValueIterator和EntryIterator继承自HashIterator,实现Iterator接口,他们在next中调用nextNode方法实现依次迭代。
1)HashIterator
abstract class HashIterator { Node<K,V> next; // next entry to return Node<K,V> current; // current entry int expectedModCount; // for fast-fail int index; // current slot HashIterator() { expectedModCount = modCount; Node<K,V>[] t = table; current = next = null; index = 0; if (t != null && size > 0) { // advance to first entry do {} while (index < t.length && (next = t[index++]) == null); } } public final boolean hasNext() { return next != null; } final Node<K,V> nextNode() { Node<K,V>[] t; Node<K,V> e = next; if (modCount != expectedModCount) throw new ConcurrentModificationException(); if (e == null) throw new NoSuchElementException();//next=e.next//如果next为空,则调整next指向下一个非空桶中的头结点,依次遍历所有的桶 if ((next = (current = e).next) == null && (t = table) != null) { do {} while (index < t.length && (next = t[index++]) == null); } return e; } public final void remove() { Node<K,V> p = current; if (p == null) throw new IllegalStateException(); if (modCount != expectedModCount) throw new ConcurrentModificationException(); current = null; K key = p.key; removeNode(hash(key), key, null, false, false); expectedModCount = modCount; } }
2)KeyIterator
//KeyIterator,每次获得下一个node的key final class KeyIterator extends HashIterator implements Iterator<K> { public final K next() { return nextNode().key; } }
3)ValueIterator
//ValueIterator:每次获得下一个node的value final class ValueIterator extends HashIterator implements Iterator<V> { public final V next() { return nextNode().value; } }
4)EntryIterator
//EntryIterator每次获得下一个node对象 final class EntryIterator extends HashIterator implements Iterator<Map.Entry<K,V>> { public final Map.Entry<K,V> next() { return nextNode(); } }
entrySet、keySet
1)entrySet
方法:new了一个EntrySet对象
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es; return (es = entrySet) == null ? (entrySet = new EntrySet()) : es; }EntrySet类,继承自AbstractSet:Iterator方法new了一个EntryIterator用来遍历所有的node
final class EntrySet extends AbstractSet<Map.Entry<K,V>> { public final int size() { return size; } public final void clear() { HashMap.this.clear(); } public final Iterator<Map.Entry<K,V>> iterator() { return new EntryIterator(); } public final boolean contains(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<?,?> e = (Map.Entry<?,?>) o; Object key = e.getKey(); Node<K,V> candidate = getNode(hash(key), key); return candidate != null && candidate.equals(e); } public final boolean remove(Object o) { if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>) o; Object key = e.getKey(); Object value = e.getValue();//删除调用removeNode return removeNode(hash(key), key, value, true, true) != null; } return false; } public final Spliterator<Map.Entry<K,V>> spliterator() { return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0); } public final void forEach(Consumer<? super Map.Entry<K,V>> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e); } if (modCount != mc) throw new ConcurrentModificationException(); } } }
2)keySet
方法:new了一个KeySet对象
public Set<K> keySet() { Set<K> ks = keySet; if (ks == null) { ks = new KeySet(); keySet = ks; } return ks; }KeySet类,继承自AbstractSet类:Iterator方法new了一个KeyIterator迭代器
final class KeySet extends AbstractSet<K> { public final int size() { return size; } public final void clear() { HashMap.this.clear(); } public final Iterator<K> iterator() { return new KeyIterator(); } public final boolean contains(Object o) { return containsKey(o); } public final boolean remove(Object key) {//调用removeNode删除 return removeNode(hash(key), key, null, false, true) != null; } public final Spliterator<K> spliterator() { return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0); } public final void forEach(Consumer<? super K> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e.key); } if (modCount != mc) throw new ConcurrentModificationException(); } } }
3)values:
方法:new了一个Values对象
public Collection<V> values() { Collection<V> vs = values; if (vs == null) { vs = new Values(); values = vs; } return vs; }Values类,继承自Collection,因为collections中允许重复,set中不允许。
iterator方法创建了ValueIterator。
final class Values extends AbstractCollection<V> { public final int size() { return size; } public final void clear() { HashMap.this.clear(); } public final Iterator<V> iterator() { return new ValueIterator(); } public final boolean contains(Object o) { return containsValue(o); } public final Spliterator<V> spliterator() { return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0); } public final void forEach(Consumer<? super V> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e.value); } if (modCount != mc) throw new ConcurrentModificationException(); } } }
四、内部类
static class Node<K,V> implements Map.Entry<K,V> { final int hash;//该节点的hash值 final K key; V value; Node<K,V> next;//指向下一个节点的指针 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; } }
五、总结
(2)根据node的key求hash。node.hash=key.hashcode^(key.hashcode>>>16),这样能保证结果的低16位都是key.hashcode的全部bit作用的结果。最后映射的Bin序号=hash&(n-1),结果一定映射在0-n-1上,原因:n是table.length,(1)中保证了n一定是2的整数次幂,那么n-1的二进制表示中,低位全为1,则与hash相与的结果是直接保留了hash中不大于n-1的所有bit,结果就与hash直接对n取模的效果一样,不过&速度更快。
(3)初始化。可以通过构造函数传递thr(这里指定的thr,虽然这个变量的含义是扩容的临界值,但是此处传递进去相当于设置的cap,具体原因在resize中)和f构造因子的值,但是在构造函数中并不对table初始化,也不会申请空间。table的初始化在put第一个节点时进行,实现在resize中。
(4)resize。实现两个3个功能。
初始化:若没有初始化,则对table进行初始化,若new hashmap对象时没有指定thr则采用默认值(cap=16,f=0.75)进行,若指定了thr,则cap=thr,thr=cap*f;
扩容:若已经初始化了,则对cap、thr进行*2扩容,扩容前检查cap是否已经达到最大值,达到则直接将thr=cap返回,否则都要进行*2扩容。然后给table重新new 一个newCap的空间。
转移node:oldtable中的node依次链接到newTable中。对于桶i,由于扩容是直接进行*2,则i中的node要么直接映射到newTable中的桶i,要么是桶(i+oldCap),原因:还是考虑newCap-1和oldCap-1的二进制形式,newCap-1比oldCap-1最高位多了一个1,低位完全相同,因此进行hash&(n-1)时相当于直接在i上+oldCap或者不变,这取决于hash的第newcap最高位所在是1还是0。resize中直接将hash&oldCap为1还是0,将oldTable[i]中的Node组成两个链表,分别链接进newTable中的i号桶和i+oldCap号桶中。
(5)关于map.put、map.get和map.remove
put:可能进行resize初始化,resize扩容,treeifyBin。
首先查看table是否初始化,没有则需要进行resize()初始化。
初始化后根据hash&(n-1)找到对应的Bin,
若bin中没有节点,则直接new一个node加入该bin。
bin中有节点,则查看第一个节点是否是要找的node,
如果是直接标记该节点指针,
否则,区分该桶中是单链表node还是treenode,
treenode则调用红黑树的查找方法来找到node,标记指针,
Node则查找这条单链表上是否有与key相等的Node,
没有则直接加入链表尾部,插入后检查该bin中是否需要treeifyBin(当单链表个数>=8则转化成红黑树);
有则找到该node,标记指针;
标记指针不为空,则表示是更新节点,直接替换掉node的value。
还要检查该table此时是否需要扩容,因为插入一个新节点可能导致table中桶占用的个数增大(该node映射到一个新Bin中),导致需要扩容。
get:
前提:table!=null&&table.length>0&&table[hash&(n-1)]!=null
根据hash映射到对应的桶,如果bin的头结点是要找的指针,则直接返回头结点。
否则区分是treeNode还是node,
treenode则调用红黑树的查找;
node则直接遍历单链表查找;
返回查找到的node
remove:
前提:table!=null&&table.length>0&&table[hash&(n-1)]!=null
根据hash映射到对应的桶,如果bin的头结点是要找的指针,则直接返回头结点。
否则区分是treeNode还是node,
treenode则调用红黑树的查找,标记查找到的node;
node则直接遍历单链表查找,标记查找到的node;
若查找到的Node!=null,则区分treeNode和node分别进行删除。(treenode的删除中可能会调用untreeify退化成单链表)
(6)entrySet、keySet和values方法
分别返回一个EntrySet、KeySet和Values类型的对象,对象的类型分别继承自Set、Set和collection,都包含一个Iterator方法,该方法内部分别返回一个EntryIterator、KeyIterator和ValueIterator类型的迭代器,对象的类型都继承自HashIterator抽象类,EntryIterator、KeyIterator和ValueIterator内部的next方法都是调用父类HashIterator的nextNode方法来实现对table中所有bin中Node的依次遍历。
- JAVA 集合类(java.util)源码阅读笔记------HashMap
- JAVA 集合类(java.util)源码阅读笔记------ArrayList
- JAVA 集合类(java.util)源码阅读笔记------LinkedList
- JAVA 集合类(java.util)源码阅读笔记------WeakHashMap
- JAVA 集合类(java.util)源码阅读笔记------Vector
- JAVA 集合类(java.util)源码阅读笔记------Stack
- JAVA 集合类(java.util)源码阅读笔记------Hashtable
- java集合源码阅读笔记-HashMap
- Java集合源码阅读之HashMap
- Java源码阅读-HashMap
- Java源码阅读-HashMap
- java.util.HashMap源码初探
- java.util.HashMap源码解析
- Java集合HashMap源码
- Java集合源码----HashMap
- Java集合类源码阅读
- java类库的阅读笔记_jdk1.7.0_40_java.util.HashMap
- java.util.concurrent 源码阅读
- oracle 分组函数 在select 中显示不是分组字段的函数
- Java学习笔记--JSP
- What is an LDS file?
- .NET 使用ORACLE ADO.NET 经常会遇到的问题
- c语言32个关键字_enum
- JAVA 集合类(java.util)源码阅读笔记------HashMap
- vue-cli中引入element
- 算法竞赛入门经典 UVa815 Flooded!
- 中石油暑假集训 母鸡下蛋
- 第一次发啊!
- tree 树 搜索关键字
- 【mysql】log模块
- C语言32个关键字_switch,case break,default
- visual studio远程调试内网机器