一、继承关系
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或者treeNode
transient 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.75
static 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);
}通过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表示在删除时不移动其他node
final 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;
}
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;
}
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;
}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();
}
}
}四、内部类
(1)实现Map中的Entry接口的实现类，静态内部类
实际上是一个链表的节点的数据结构
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;
}
}五、总结
（1）table的cap一定为2的整数次幂。每次设置cap之前都调用tableForSize(指定的cap)来获取一个大于指定cap的最小的2的整数次幂，从而保证table.length一定为2的整数次幂，可以小于默认的初始容量16。
（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的依次遍历。
（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的依次遍历。
扫一扫
658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
