HashMap中的底层的结构是由数组加链表组成的（当链表的元素超过八个的时候，链表转换成为红黑树。）
而对对于数组中每个结点却是由Node组成的。
这里数组对应的就是table, 而每个结点是由Node包含了四个属性，hash,key,value next这四个属性，hash是用来判断在数组中的索引位置，key表示键值，value表示的确定的值。next表示的是下一个node的值。
transient Node<K,V>[] table;
static class Node<K,V> implements Map.Entry<K,V> {
final int 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;
}
}
对于HashMap中的几个参数的解释
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;
int threshold;
其中 默认的初始值是指当我们没有指定HashMap的大小的时候，会有一个默认值为16，最大值是指table数组的最大容量，TREEIFY_THRESHOLD 这个值代表的是什么时候需要进行红黑树的转换，当链表中的值超过多少的时候需要进行红黑树的转换。threshold指的是临界值，即当大于这个值的时候需要对HashMap进行扩容。
loadFactor是负载因子：负载因子的意思是指table数组当中最多能够容纳的数量。
关于负载因子，是空间和时间的综合考虑的结果。如果负载因子过小的话，即一个数组里面的内容很少会造成内存空间的浪费。如果负载因子过大的话，表示的是数组的内容比较多，这个时候便会更多的出现哈希碰撞，时间效率就会降低。
关于哈希碰撞：是指如果两个node在数组的中位置相同的话，那么便会出现哈希碰撞。解决哈希碰撞的方法，一个是开放地址，另一个是用链表的形式解决问题。但这样都会导致时间复杂度变高。
HashMap中put的操作
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;
//首先判断对于当前的数组有没有赋予初始值，如果没有的话便去重新加载一下。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//判断在数组的hash&(n-1)的位置。有没有值如果没有值的话，新建一个节点放在这，
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//如果数组中有值的话，判断当前节点时候等于我们要更新的节点（通过判断这个key的地址时候等于当前值的地址，或者是通过equals的方法来判断。），如果是的话直接取到这个节点，这个对应的是更新。
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果不是的话，但是这个节点是红黑树的节点，直接用红黑树的思想去更新或者去创建节点。
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果他只是一个普通的节点的话。遍历链表，如果遍历到最后都没有找到相同的key，那么直接新建一个node，如果加上这个节点以后脸变肿的数目超过了8个，那么要把这个链表转换成为红黑树。
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果找到了key相同的值，那么通过p提前取到了这个值。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//最后如果得到了这个e值，更新这个值，并且返回原来的值。
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//如果是在table数组当中添加了新的值以后，那么判断当前的容量是不是超过了临界值，超过临界值的话那么便resize()
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- 当调用put的时候，put会调用HashMap当中的putVal方法。解释其中的hash(key)见一
- 对于putVal中的几个参数的含义int hash, K key, V value, boolean onlyIfAbsent，//如果为真的话，不改变当前的值boolean evict//这个值没有什么特殊的含义。
- 然后就是在putVal当中的逻辑判断，首先要解释的table[hash&(n-1)]见三，其次要解释resize（）见四。
一 关于hash(key)
//当key==null 的时候返回的hash值为0，也就是说当key==null 的时候，是可以放入到HashMap当中去的。另外就是对于hash值的计算：是先计算出key的hashcode然后h>>>16,因为int值是三十二位，让高位参与hash，这样便得到的是高16位与低16位的异或。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
三 table[hash&(n-1)]
hash&(n-1) 的意思是指：这里提到了n-1，n代表的是数组的总容量（数组的总容量是2的整数次幂）这样的优点有两个：一是方便了计算在数组中的索引，二是：在数组扩容的时候，可以使hash更加均匀分布。详细见resize。
因为n是2的整数次幂，所以n-1便是除了最高位，后面的全是1，这样hash&（n-1）的效果等同于hash%n，在Java中&比%运算效率高很多。
四 resize()
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) //把当前容量值赋值给最大值
newCap = oldThr;
else {
//这里是对应的是当数组的容量介于0-16之间的时候。
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {//最容临界值为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) {
//遍历原来的数组。oldCap
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
//如果当前的node节点没有临近的节点，那么直接赋值，并且将原来的设置为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
//如果是链表的话，这里创建了四个节点，一组是用来存储位置不变的节点，一组是用来存储在原来数组中位置改变的节点。
//其中head存储的是头节点，每次都是让tail尾部节点去循环
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {//判断的是oldCapacity那一位是0还是1，如果是0的话证明在原来的位置不变，如果是1的话表示要改变其在数组中的位置。
/**
下面的判断的逻辑是：head用来保存头节点，然后利用tail去遍历下面的值，把后面的值全部加载后面，最后将tail.next == null
然后保存在相应的位置上面。
*/
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;
}
关于e.hash&oldCapactiy:因为一开始默认的是h&(oldCapactiy-1),这样oldCapacity的最高位如果是1的话，表示他会改变位置，否则的话，便不会改变位置。
另外一个经典的部分：当数组中的容量不为2的整数次幂的时候，怎么修正为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且最小2的幂
比如cap=1 结果 2 0次方 1
cap=2 2
cap=3 4
cap=9 16
分析下等于9
cap - 1 第一步结果8
00000000000000000000000000001000 8
00000000000000000000000000000100 右移1位
00000000000000000000000000001100 或运算 结果
00000000000000000000000000000011 右移2位
00000000000000000000000000001111 或运算 结果
00000000000000000000000000001111 右移 4 8 16没用全是0结果还是这个15
最终 +1 16
分析下等于大点 12345678
00000000101111000110000101001110 12345678
00000000101111000110000101001101 -1结果 12345677
00000000010111100011000010100110 右移1位
00000000111111100111000111101111 或运算 结果
00000000001111111001110001111011 右移2位
00000000111111111111110111111111 差不多了在移0就没了都是1了，+1不是肯定是2的倍数了
再说开始-1原因这是为了防止，cap已经是2的幂。
如果cap已经是2的幂， 又没有执行这个减1操作，则执行完后面的几条无符号右移操作之后，返回的capacity将是这个cap的2倍。如果不懂，要看完后面的几个无符号右移之后再回来看看
872
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
