标签：for parent 地址 相同 iter java fabs nts 分配
HashMap通常使用链地址方法存储，但是当链的长度太大（大于8）时，这个链就会转换为红黑树，类似java.util.TeeMap。大部分的方法一般使用链表，但检查到节点为树节点时，也会使用树。树状的链表可以向其他链表一样使用和遍历，但是如何HashMap中冲突严重的情况下，树状的链表查找更快。HashMap中的链表多以单链表为主，查找当前链表是否是树一般会造成延迟。
树链表按hashCode的值排列，但是为了以防万一，如何两个元素的hashCode相同，且他们都实现了Comparable
因为树的节点比链表大小要大两倍，所以只有在链表的节点很大时，我们才使用红黑树存储。当红黑树很小时，又会转成普通的链表存储。如何hashCode分布很好的话，红黑树时很少会用到的。理想情况下使用随机的hashCode，而且节点的分布服从泊松分布
红黑树的根是他的第一个节点，但是有时候树根也不是其第一个元素（使用了Iterator.remove）树根就变成其他的元素了，但使用TreeNode.root()方法就可以恢复。
1，HashMap对于自己的结构性改变（结构性改变值添加或删除一个键值组合等，只要不是修改某个key对应的value都认为是结构性的改变）不是线程同步的，
如果要实现线程同步需要在新建HashMap时，这样写：
Map m = Collectons.synchronizedMap(new HashMap(...));
如果创建了Iterator，且在遍历的过程中删除了某个元素，Iterator就会包ConcurrentModificationExeption。
在HashMap中的get方法中你会看到一种特别奇怪的写法，从table中取数时，table[(n-1)&hash]，根据“与”运算分析，这是一种取余的方法，(n-1)&hash得到的数永远小于n-1，这里又学到了一种获得小于等于某个数的新算法。
public class Test {
public static void main(String[] args) {
int a = 12;
for(int i = 0; i < 100; i ++){
if((i&a)>=a) {
System.out.println(i + "->" + (i&a));
}
}
}
}12->12
13->12
14->12
15->12
...
61->12
62->12
同时查看了其在地址中冲突的概率
public class Test {
public static void main(String[] args) {
boolean[] flags = new boolean[100];
for(boolean b : flags) {
b = false;
}
int a = 100;
for(Integer i = 0; i < 100; i ++){
if(flags[(a-1)&hash(new String(i+""))]) {
System.out.println(i + "---crash--->" + ((a-1)&hash(i)));
} else {
flags[(a-1)&hash(i)] = true;
}
}
}
public static int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
}发现其冲突率还是很高的
10---crash--->2
44---crash--->32
45---crash--->33
46---crash--->34
47---crash--->35
48---crash--->32
49---crash--->33
50---crash--->34
51---crash--->35
52---crash--->32
53---crash--->33
....
99---crash--->99
如果冲突，HashMap使用链表或 红黑树存储冲突后的节点。见如下代码解析：
/**
* 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
* @param evict if false, the table is in creation mode.
* @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;
//如果table为空，或者length=0，即没有数据，要resize()扩容
//Map刚创建完成时会走这段逻辑
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果算出的table对应位置没有数，就将其放到该位置上
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//如果冲突，要在这个节点上构造平衡树，并将数据存储到这棵树上
else {
Node<K,V> e; K k;
//如果当前节点的hash值相同，key也相同，则将该节点替换
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 {
//遍历类似链表的结构，如果找到链表的尾部，且没有超过最大长度放到链表上
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
//如果超过最大长度，则放到treeify（红黑树）结构上
treeifyBin(tab, hash);
break;
}
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;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}HashMap不是线程安全的，但是在读HashMap中的值时，其结构发生了变化，则会抛出 ConcurrentModificationException
她是通过自身的私有变量modCount控制的，modCount很像HashMap的版本号，如果其结构发生变化modCount的值肯定发生变化，代表一个新版本的HashMap产生了。
HashMap中有一个函数，用来计算比给定值大的第一个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;
}int数值占用4个字节，32bit。该算法的思路是，用给定值的最高位的1，将其最高位右边的位都填充为1。然后在加上1。
例如 cap = 20
n = cap - 1 = 19 0001 0011
n>>>1 = 0000 1001
n|=n>>>1 = 0001 1011
n>>>2 = 0000 0110
n|=n>>>2 = 0001 1111
n>>>4 = 0000 0001
n|=n>>>4= 0001 1111
n>>>8 与 n >>>16 都为0 所以最后的结果为 31（0001 1111） + 1 =32
table的size要是2的幂级数，是为了在resize()的时，对于某个node，要么不移动，要么移动到其位置*2的地方。
在resize()函数中有这样一段代码：
next = e.next;
// 如果e.hash 小于 oldCap 不移动存储的位置
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
// 如果 e.hash >= oldCap 要移动存储的位置
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;
}可以看出上面代码中设计到两个链表（loHead，loTail）和（hiHead，hiTail）。每一次循环都是往某个链表中添加一个元素。重点是为什么要弄两个链表。这是因为table中前半部分的element是不用移动的。
假设原来的capacity = 16 在往table中放数据时。都是e.hash&(capacity-1) ，数据都存放到0至15的位置。假设原来有一个element.hash < 16 则 e.hash&capacity == 0 。这里我们就明白了，原来table前部中的元素是不需要移动的。如果原来链表中存储着e.hash >= 16 的，这是在 e.hash & capacity != 0 这时就将其存储到table的后半部分。因为在resize()时调用的时oldCap == 16 当table.length = 32 时，我们假设原来有一个元素 e.hash ==18
e.hash & oldCap == 2，当再次分配时，会走（hiHead，hiTail）这段逻辑，放在角标为16+2 的位置。当扩容完成，我们用新的容量取余时，会计算的到18。证明在扩容时放数据的位置没有问题。
当节点为TreeNode时，调用TreeNode的split方法。在处理树节点时，也是先按链表处理，然后在重构成树。
TreeNode与Node之间的继承关系：
而且TreeNode中有一个变量prev
//bit 当前table长度
//e 当前树节点
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
//如果e.hash小于当前table的长度，
if ((e.hash & bit) == 0) {
// 如果loTail为空，说明当前链表中没有数据
if ((e.prev = loTail) == null)
//数据头即为e
loHead = e;
else
loTail.next = e;
// 每次添加一个节点就将loTail指向当前节点
loTail = e;
// 计数器 +1 为了根据这个数值的大小决定存储成树形，还是链表
++lc;
}
else {
// 如果 e.hash >= 当前table的长度
// 如果当前链表中没有数据
if ((e.prev = hiTail) == null)
// 将数据头指向当前节点
hiHead = e;
else
// 如果当前链表不为空，则在链表的尾部加上一个节点
hiTail.next = e;
// 尾部永远指向最后添加的节点
hiTail = e;
++hc;
}
}
// 当前链表遍历完成后，根据计数器决定其存成什么样子。
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);
else {
tab[index] = loHead;
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}下面就应该看treeify(tab)的实现了，这个实现就是将单向链表转换为红黑树的过程。
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
//当前节点为x
for (TreeNode<K,V> x = this, next; x != null; x = next) {
// next为下一个节点
next = (TreeNode<K,V>)x.next;
// 当前节点的左右子节点清空
x.left = x.right = null;
// 第一次进入时，根为空，这是给根赋值，且将根节点标记为黑色
if (root == null) {
x.parent = null;
x.red = false;
root = x;
}
// 如果不是第一次进入
else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
// 如果根节点的hash比当前节点的hash大
if ((ph = p.hash) > h)
dir = -1; //存到左边
else if (ph < h)
dir = 1; // 存到右边
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
// 如果dir < 0 且 p 指向根节点的左子节点，如果dir > 0 p 指向根节点的右子节点
// 如果 p 指向的子节点为空，则要存入树中的节点存入子节点，否则，p指向其某个子节点，然后重复for循环
if ((p = (dir <= 0) ? p.left : p.right) == null) {
// 当前节点的父节点为根节点
x.parent = xp;
// 根据dir 将x存入根节点的子节点中
if (dir <= 0)
xp.left = x;
else
xp.right = x;
// 保证树的平衡
root = balanceInsertion(root, x);
break;
}
}
}
}
moveRootToFront(tab, root);
}这篇文章对看懂红黑树插入数据操作有用：https://zh.wikipedia.org/wiki/%E7%BA%A2%E9%BB%91%E6%A0%91
HashMap为什么使用红黑树而不使用平衡树呢？
作者：知乎用户
链接：https://www.zhihu.com/question/20545708/answer/58717264
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
红黑树为满足如下条件的二叉搜索树：
下面是关于删除元素的代码解释：
/**
* Implements Map.remove and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to match if matchValue, else ignored
* @param matchValue if true only remove if value is equal
* @param movable if false do not move other nodes while removing
* @return the node, or null if none
*/
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为空，或没有数据，或者某有节点的给定hash没有对应的元素，则直接返回空
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;
// 如果找到这样一个节点的hash,key 都和给定的值相等，则将其记录到node中
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
// 否则 如果其有下一个节点
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
// 如果当前节点存的是树，则直接从树种找
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
// 否则即为链表，从链表中查找
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e; // p一直指向e的前一个节点
} while ((e = e.next) != null);
}
}
// node != null 表示找到了对应的节点，如果要值相等，这值相等，否则值不等于空，且值也要相等
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// 如果当前节点为树，则要从树种移除
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
// 如果是链表中的第一个节点，tab[index]存链表头的地方指向其下一个节点
else if (node == p)
tab[index] = node.next;
else
// 否则 将找到的节点从链表中删除
p.next = node.next; // p一直指向e的前一个节点
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}关于红黑树的旋转建议百度
标签：for parent 地址 相同 iter java fabs nts 分配
原文地址：http://www.cnblogs.com/arax/p/7953427.html
