HashMap
Map, Cloneable, Serializable
–>AbstractMap
HashMap内部是通过一个n大小的table实现的,table的每一个位置被称为一个桶,桶内可能包含很多的节点(存有key和value等值),每一个桶内的节点通过链式或树形储存。HashMap是一个fail-fast的容器。其每次扩容后的新桶数都是当前桶数的两倍(当前桶数是2的次幂)。
默认常量
// 默认HashMap容量,为2的倍数
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载,若(元素个数/桶数)>负载,则扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 1.若每一个桶内的元素个数超过TREEIFY_THRESHOLD,
* 则将该桶内的链式存储结构调整为红黑树
* 2.若每一个桶内的元素个数小于UNTREEIFY_THRESHOLD,
* 则将该桶内的红黑树结构还原为链式结构
* 注意:若桶数小于MIN_TREEIFY_CAPACITY,
* 即使达到条件1,只会进行扩容而不会调整储存结构
*/
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
HashMap的内部存储结构
链式结构
HashMap内部每一个子元素均以Node形式存储,如下所示,里面包含一个hash值,一个key值,一个value值和指向下一个Node的指针。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
// 计算hash值得方法:将key的hash值和value的hash值进行异或
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
}
红黑树结构
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
}
// TreeNode最终继承至Node,该红黑树结构比普通红黑树结构稍复杂,
// 因为TreeNode里还存了Node的next指针以退化为Node
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
}
成员变量
// table中的每一个元素代表一个桶
transient Node<K,V>[] table;
// 并未使用额外的空间进行存储,通过调用HashMap中定义的其他方法模拟出entrySet的效果
transient Set<Map.Entry<K,V>> entrySet;
// 已储存的元素个数
transient int size;
// 和其他非线程安全容器类似,为了fail-fast
transient int modCount;
// 负载(默认值或赋新值)
final float loadFactor;
// 定义为(capacity * load factor),size超过该值即重新分配空间
int threshold;
注意,在调用HashMap构造函数后并未立刻给table分配内存空间,而是在第一次进行插入操作时分配空间。
辅助方法
hash
HashMap重写的hash方法,采用将key值调用Object.hashCode方法得到的hash值的后16位与前16为进行异或,前16位保持不变得到新的hash值。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
使用该方法的原因如下:
在HashMap中通过hash值计算得到内存的方法为index=hash&(n-1)
,n为table大小,即桶的数量,且n值为2的幂次,因此该方法会造成在计算Index时仅后
log2n
位生效。
引自博客http://blog.csdn.net/fan2012huan/article/details/51097331
tableSizeFor
该方法的主要作用是将输入的桶的数量(cap)变成大于cap的最小2次幂的数。
static final int tableSizeFor(int cap) {
// 当cap为2的次幂时,保证使用该方法不改变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;
}
该方法的原理如下:
以cap为1**************为例,*代表该位置上的数是任意数
n |= n >>> 1;
1************** -> 11*************,将最高位的1向右传递了2位。
n |= n >>> 2;
1************** -> 1111***********,将最高位的1向右传递了4位。
n |= n >>> 4;
1111*********** -> 11111111*******,将最高位的1向右传递了8位。
n |= n >>> 8;
11111111******* -> 111111111111111,将最高位的1向右传递了16位(位数不够,仅传递了15位)。
n |= n >>> 16;
最大能将最高位的1向右传递32位,和一个int值得位数相同。
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
最后返回(n+1),即为2的次幂。
查找元素的实现
该方法在HashMap的内部频繁被其他方法调用。该方法的实现原理其实就是根据hash值定位到桶,再从桶中查找到期望的Node。注意,即使在桶内,每一个if的最开始都判断了一次hash值是否相同,这是因为桶的标号是通过index=hash&(n-1)
计算得到,在之前解释过,这样在计算index时只会用到后n为hash值,因此有可能不同的hash值都定位到同一个桶中。
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;
}