数据结构
底层数据结构：
java8：数组+链表+红黑树
java7：数组+链表
数组：查询快，增删慢
链表：增删快，查询慢
红黑树：一种平衡的二叉树。
概念组成
数组的初始容量：
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;
链表扩容为红黑树的长度：
static final int TREEIFY_THRESHOLD = 8;
红黑树转换成链表的长度：
static final int UNTREEIFY_THRESHOLD = 6;
红黑树转换的最小容量：
static final int MIN_TREEIFY_CAPACITY = 64;
容量扩容的阈值，等式为0.75*16=12 即是扩载因子乘以数组容量
int threshold;
存放key，value的数量，包括在数组上和链表上。
transient int size;
存放entry对象数组的容量
int capacity();
常见问题
为什么hashmap的底层是数组+链表+红黑树？
为什么hashmap的扩载因子是0.75？
为什么数组的容量一定要是2的n次冥？
java7中的hashmap存在什么样的问题？
java8中相对于java7优化了那些地方？
为什么hashmap的链表转红黑树的链表长度是8？
为什么hashmap的红黑树转链表的长度是6？
源码分析
hashmap初始化容器
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//初始也就是容量的赋值和扩载因子的赋值
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);
}
注意：我们可以通过有参构造来构建hashmap的初始化容量和扩载因子。并且限制了初始化容量的大小范围，也赋值了扩容阈值，这里的扩容阈值是2的次冥，还未进行真正使用，hashmap会在put的时候进行threshold的再次赋值。
hashmap容量2的n次冥
给自定义容量的数值变成大于或者等于该值且最近的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;
}
注意：
- cap指的是传入的容量，这里第一步-1的操作和是为了解决传入的容量正好是2的次冥问题。
- n |= n >>> 1，传入的值无符号右移后，在于该值进行与运算，那么低四位的结果一定是1111， 那么转换为十进制则是2的n次冥-1
- 依次无符号右移1，2，4，8，16是因为传入值int类型占四个字节，一个字节八位，那就是32位。最后的三元表达式则是2的n次冥结果。
- 不得不佩服写算法的作者了。至于为什么是2的次冥，后面会提到。
hashmap无参构造
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
注意：hashmap在被创建的时候，无参构造的时候，只存储了扩载因子的大小，使用默认值0.75
hashmap-> hash方法
//key是传入键值对中的键。
static final int hash(Object key) {
int h;//h则是hash结果后的int类型的一个数值
//h在hashcode之后赋值，异或运算h右移16位。
//异或运算的特点是相同返回0，不同返回1,那么h右移16，则是把高位的值也拉去到运算中。让hash值更加散列。
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
hashmap-> put方法
public V put(K key, V value) {
//这里的hash方法就是上面的方法
return putVal(hash(key), key, value, false, true);
}
public V put(K key, V value) {
//zfinal V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//局部变量tab是数组元素上某一个索引上的存储的真实对象
//p则是tab上 数组索引所在的对象（元素）。
//i是索引
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
//如果tab不为空和长度=0则去扩容
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//i = (n - 1) & hash 这里解释为什么hashmap的容量是2的n次冥，我们可以这样去理解。因为这一行代码是为了计算出元素所在数组中的索引位置。比如默认容量是16，那么16-1=15，15的二进制是0000 1111，并且与key的hash值进行与运算，与运算特点是同位都为1则是1，那么结果则是0000 ****(这里的星指的是可能为1，可能为0)，所以结论则是 低四位决定了数组的索引位置。因为****是有你key计算得出的hash值得低四位决定。所以可能是0-15得任何一个值，也符合索引不越界得规范。这是我们正常按照2的n次冥去推到的结果，那么怎么验证就一定是2的n次冥了，我们反推一下，如果容量不是2的n次冥，我们这里举例17为容量，那么过程测是 17-1=16，16的二进制是0001 0000 &hash值，结果要么就是0000 0000 要么就是0001 0000，得到的结果则是索引0或者索引16,那么不管你传入的key是什么，存储的元素就只会在两个索引位置上，完全不均匀的散列在数组上，则推导出2的n次冥作为hashmap的容量的规则。
//这里在讲诉下，计算元素所在数组中的索引java4曾使用取模运算去计算。结果和java8的结果一样，但是取模运算是效率很低的，所以被遗弃了。
//该数组上索引所在位置为空，则将数据存储到该位置。
tab[i] = newNode(hash, key, value, null);
else {
//不为空 就要去找该索引上的数据结构，e对象为链表上的元素。
Node<K,V> e; K k;
//这里优先判断数组上的元素的hash和传进来key的hash是否一致，和后面的key.equals(k)可能k会被重写，效率低下，形成短路效果。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//存储在数组上的元素完全匹配到传入的key一致，则赋值给e。
e = p;
//判断节点是树形结构
else if (p instanceof TreeNode)
//转变成红黑树结构
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//遍历链表
for (int binCount = 0; ; ++binCount) {
//下一个节点等于空则放在下一个节点，这里说明下java8中就是尾插法，java7是头插法，头插法会导致列表循环造成死循环在多线程情况下。
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果链表结构>=8则开始转换成红黑树
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;
}
}
//返回就得value值，和替换value
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;
}
hashmap的扩容方法 newCap = oldCap << 1
比如 16，0001 0000 左移一位 0010 0000 就是32 2的n次冥 低位都是0
newThr = oldThr << 1;
比如12，0000 1100 左移一位 0001 1000 就是24 两倍
0001 0000 & hash 结果是 低位都是0000 高位可能是0或者1 结果就是16或者0
比如说hash值是000 0110 也就是索引6 & 0001 0000 结果为0000 0000 为0
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 wbile 因外外层已经判断了下一个节点一定会有值。一定会执行。
do {
next = e.next;
//当前数组索引所在的元素与容量与运算。高位为1则是存储到旧数组索引+容量，高位为0则指向的还是老数组所在的索引位置。
//这里的特点可以参照容量是2的n次冥思想。
//else则是高位=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);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
