在【初探】篇中，记录了HashMap源码在刚开始阅读时遇到的惊喜，本篇文章将进一步记录HashMap源码中的主要方法。
HashMap作为一个用于存与取的类，众多方法中最重要的就是put与get。
put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}调用put方法实际上就是调用putVal方法，前三个参数中的key和value就是大家调用put时传入的键、值，hash由key.hashCode()的低16位与高16位异或获得。
static final int hash(Object key) {
int h;
//通过hashCode的高16位异或低十六位获得哈希值
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}">>>"表示无符号右移，也叫逻辑右移，无论数为正或负，右移后高位均补0。
与之相对的，">>"表示（带符号）右移，即右移时，若数为正高位补0，若数为负高位补1。
/**
* 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
* onlyIfAbsent是true，新值不会替换旧值。put方法传入的是false,因此新值会替换旧值
* @param evict if false, the table is in creation mode.map
* 初始化的时候evict为false,其他情况为true,用于LinkedHashMap
* @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;
//如果数组（哈希表）为null或者长度为0，则初始化数组
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//(n - 1) & hash = hash % n（但，位与运算性能高于模运算）,
//这里其实是一个模运算，取余数，因为余数绝不会大于（n-1），因此不会越界。
tab[i] = newNode(hash, key, value, null);//放一个新的Node到数组中
else {
Node<K,V> e; K k;
//如果目标位置key已经存在，则找到目标节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//数组中的节点p与传入的key不重复，则顺着节点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) {
//如果到末尾，key都不存在，则在末尾插入一个新Node
p.next = newNode(hash, key, value, null);
//如果链表长度大于TREEIFY_THRESHOLD，考虑转为红黑树（不一定转，treeifyBin方法中还有判断）
//为什么说是大于，而不是大于等于，因为在比较的时候，新插入末尾的节点还没算进去
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 为什么需要-1？因为binCount从0开始
treeifyBin(tab, hash);
break;
}
//链表中已经存在该key，则找到目标节点
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果存在被覆盖的情况，则返回被替换的值，也就是e的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)//判断是否用新值取代旧值
e.value = value;
afterNodeAccess(e);//节点被访问后执行的方法，HashMap中该方法为空，用于LinkedHashMap
return oldValue;//返回旧值
}
}
++modCount;//操作数+1，说明map被操作（put）过了,类似数据的版本号
//如果元素的数量大于阈值，则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}put方法调用putVal时，传入的onlyIfAbsent、evict分别为false、true。
参数evict在HashMap中并未使用到，其用于LinkedHashMap判断是否移除最老的节点（头节点）。题外话：LinkedHashMap中传入了evict=true，也并不能起到移除的效果，因为：
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}注释也很委婉，possibly remove eldest， 可能删除最老的节点。为什么说是可能？那是因为判断中还需要removeEldestEntry方法为true才行，而LinkedHashMap中的removeEldestEntry实现如下：
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}看到这里，有的同学就要发出一段。。。了，折腾了半天，不就还是不能移除最老节点吗！！！非也， LinkedHashMap默认是不移除最老节点，但支持开发者重写removeEldestEntry方法来表达什么样的条件下才返回true来移除最老节点，这里我写了一个例子：
HashMap<Integer, String> lMap = new LinkedHashMap<Integer, String>(){
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
return size()>2;
}
};
lMap.put(1,"第一个");
lMap.put(2,"第二个");
lMap.put(3,"第三个");
System.out.println(lMap.get(1));
System.out.println(lMap.get(2));
System.out.println(lMap.get(3));输出的结果为：
null
第二个
第三个
结果显而易见，个数达到3个，超过2时，最老的节点被移除了。
参数onlyIfAbsent如果为true，无论原始的value是否为空，都不会被替换，这个参数在源码中的体现如下：
//如果存在被覆盖的情况，则返回被替换的值，也就是e的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
//onlyIfAbsent为false或者原先的value为null,则用新传入的value替换原先的value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}注意：put在调用时，传入onlyIfAbsent为false，因此使用put方法新value会替换原始value，方法返回为原始value。
putVal方法中出现的afterNodeAccess、afterNodeInsertion两个方法，加上另外一个afterNodeRemoval方法共三个方法，作为LinkedHashMap的节点操作回调方法，保证了LinkedHashMap插入、删除操作后的有序性，因此在HashMap（无序）中均无实现。
// Callbacks to allow LinkedHashMap post-actions
//这三个方法表示在访问、插入、删除某个节点后的操作，
//在LinkedHashMap中实现，LinkedHashMap正是通过这三个方法保证链表插入、删除的有序性。
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }get方法
public V get(Object key) {
Node<K,V> e;
//节点存在就返回节点的value，节点不存在即返回null。
return (e = getNode(hash(key), key)) == null ? null : e.value;
}调用get方法实际上就是调用getNode方法，传入的参数为key的hash值、key，返回会去到的Node。
/**
* 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;
//先找目标对象的hash找到其在数组中的位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {//(n - 1) & hash 计算数组位置，和存的时候计算方式一致
//如果目标索引位置元素就是要找的元素则直接返回
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);
//否则类型为链表，遍历链表寻找key匹配的Node
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}简单来说，getNode方法就是先通过hash值找到目标节点在数组table中的位置，再进一步遍历链表（红黑树）准确定位到Node。
resize方法
put方法中可以发现，如果数组为空或map的键值对数量超过了扩容阈值threshold，都会调用resize()方法对数组进行初始化或扩容。
/**
* The number of key-value mappings contained in this map.
*/
transient int size;
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
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;
}
//newCap = oldCap << 1 新容量为旧容量的两倍，但不能大于MAXIMUM_CAPACITY
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;//16
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//加载因子（0.75）*默认初始化容量（16）=12
}
//如果新的扩容阈值为0,重新计算newThr
if (newThr == 0) {
float ft = (float) newCap * loadFactor;//数组容量*加载因子
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
(int) ft : Integer.MAX_VALUE);
}
//赋值：全局的threshold扩容阈值、table数组
threshold = newThr;
@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 维护排序
//JDK 1.8 扩容优化部分
Node<K, V> loHead = null, loTail = null;
Node<K, V> hiHead = null, hiTail = null;
Node<K, V> next;
//遍历节点e的链表（e为数组中的节点）
//判断e链表中的节点是否需要放到数组中
do {
next = e.next;
//扩容时通过高位运算e.hash & oldCap结果是否为0来确定元素是否需要调整在数组中的位置，0不用调整。
//当(e.hash & oldCap) == 0时，e.hash & (oldCap-1) 和e.hash & (2oldCap -1 )，2oldCap为新数组大小
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);
//相当于把原先的链表，[最多]拆为两个链表，一个在原来位置j，一个到j+oldCap
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}代码中，用(e.hash & oldCap) == 0来判断链表中的节点是否需要放置到新数组中的另一个位置。首先，我们需要回忆，一个节点在数组中的位置是由什么决定的？没错，就是(n - 1) & hash，也就是e.hash & (cap-1)，新的容量翻倍即为2cap，所以当e.hash & (oldCap-1) == e.hash & (2oldcap-1)时，不需要移动节点位置。
我们假设oldCap为16，newCap即为2*16=32，oldCap-1=0 1111，newCap-1=01 1111。
当e.hash=0 XXXX时，由于第五位为0，和0或1&的结果均为0，即e.hash & (0 1111) == e.hash & (01 1111)==0 XXXX，也就是无需移动其在数组中的位置；反之，e.hash=1 XXXX时，e.hash & (oldCap-1)的结果（0 XXXX）第五位是0，e.hash & (2oldCap-1)的结果（1 XXXX）第五位是1，即e.hash & (0 1111) != e.hash & (01 1111)，需要移动其在数组中的位置。
e.hash & (oldCap-1)与e.hash & (2oldcap-1)的比较，也就转化为了判断e.hash的第五位是否为1，而用oldCap = 16 =1 0000来&e.hash恰好可以用来判定e.hash的第五位是0还是1。
综上所述，e.hash & (oldCap-1) == e.hash & (2oldcap-1)可以简化为用(e.hash & oldCap) == 0来判断。
由于扩容的扩容是吧所有节点从原数组迁移到新的数组，是一个非常耗时的过程，因此若已经预知HashMap中元素的个数，那么预设元素的个数可以减少resize()方法的调用。在上一篇文章HashMap源码学习——初探中提到，HashMap数组的长度需要是2的N次幂，如果采用默认长度16，后续无论如何扩容（每次扩容长度*2）肯定都可以满足，那如果预设元素的个数如何能既满足该条件，也不浪费数组空间。
先看一下需要传入预设元素个数的构造函数
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and the default load factor (0.75).
*
* @param initialCapacity the initial capacity.
* @throws IllegalArgumentException if the initial capacity is negative.
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}继续调用需要传入预设元素个数和加载因子的构造函数，其中加载因子采用默认的0.75
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
*
* @param initialCapacity the initial capacity
* @param loadFactor the load factor
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
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);//初始化的时候，扩容阈值threshold=比初始容量initialCapacity大的2的幂
}抛开前面的一些临界判断，发现扩容阈值threshold = tableSizeFor(initialCapacity)
/**
* 根据传入的值，通过计算得到第一个比他大的2的幂并返回
* Returns a power of two size for the given target capacity.
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;//>>>无符号右移，即右移后无论正负高位均补0
n |= n >>> 2;//|符号表示或运算，高位开始比较，有1则为1，无1则为0
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}tableSizeFor方法是一个很有意思的方法，乍一看一头雾水其实充满智慧，有必要之后单独领出来说。
而通过tableSizeFor方法会得到一个比initialCapacity大的2N次幂并赋值给扩容阈值threshold。当第一次put的时候，由于数组此时为空，会调用resize方法，resize方法通过判断把threshold作为默认数组容量。所以初始化HashMap时并没有创建数组，而是在第一次put的时候进行创建。
扫一扫
170
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
