前言
前言点击此处查看:
http://blog.csdn.net/wang7807564/article/details/79113195
Map
Map接口有几个实现的类，常用的是HashMap和TreeMap,这两个都不是线程安全的。Hashtable也是实现了Map接口的一个类，是线程安全的。
Map接口定义了一个名为Entry的内部接口，该接口封装了对一个K－V对的操作，一般通过entrySet()方法获取。而使用keySet()获取到的是Map中键的集合。
TreeMap
TreeMap类实现了数据结构中的红黑树。其相对于Map的另一种基于哈希表的实现方式，虽然随机查找的效率要差，但是插入数据的顺序是有序的。可以根据不同的应用场合来选择使用红黑树的实现还是哈希表的实现。
红黑树是一种自平衡二叉查找树，在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。其在最坏情况下查找效率仍然很高，插入，查找，删除时的时间复杂度都是O(logn).红黑树在二叉查找树的基础上，还具有以下几点特征：
性质1. 节点是红色或黑色。
性质2. 根节点是黑色。
性质3 每个叶节点或空节点是黑色的。
性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
这样做的好处是:从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。使得这个二叉树大致上是平衡的。插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例。因此，这个在高度上的理论上限允许红黑树在最坏情况下仍然很高效，而不同于普通的二叉查找树。
红黑树的另外一个特点就是，当每次对这棵树进行修改时，诸如删除和插入，都会调整这棵树的结构。调节的过程是通过旋转和着色来完成的，通过调整来实现修改后的红黑树符合上述红黑树的特征。
JDK源代码中，是通过如下的代码来实现这棵红黑树的:
- 实现节点
红黑树的每一个节点实现了Map接口中的Entry内部接口:
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;
V value;
Entry<K,V> left;
Entry<K,V> right;
Entry<K,V> parent;
boolean color = BLACK;
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
}
public int hashCode() {
int keyHash = (key==null ? 0 : key.hashCode());
int valueHash = (value==null ? 0 : value.hashCode());
return keyHash ^ valueHash;
}
public String toString() {
return key + "=" + value;
}
}- 取节点
public V get(Object key) {
Entry<K,V> p = getEntry(key);
return (p==null ? null : p.value);
}
final Entry<K,V> getEntry(Object key) {
// Offload comparator-based version for sake of performance
if (comparator != null) //构造函数指定了比较器的情况
return getEntryUsingComparator(key);
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
Entry<K,V> p = root;
while (p != null) {
int cmp = k.compareTo(p.key); //默认使用compareTo()方法来比较
if (cmp < 0) //二叉搜索树的特性
p = p.left;
else if (cmp > 0)
p = p.right;
else
return p;
}
return null;
}- 增加节点
public V put(K key, V value) {
Entry<K,V> t = root;
//判断是否没有加入过任何元素,如果是,则初始化根节点.
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
/*使用自定义比较器或默认比较器来定位到叶子节点,如果该K值已经存在,则用新值替换掉旧值,并返回旧值;如果该K值不存在,则记录该叶子节点作为后续添加新节点的父节点。
*/
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
//添加新节点
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
//旋转与着色
fixAfterInsertion(e);
size++;
modCount++;
return null;
}红黑树的旋转与着色:
private void fixAfterInsertion(Entry<K,V> x) {
x.color = RED;
while (x != null && x != root && x.parent.color == RED) {
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == rightOf(parentOf(x))) {
x = parentOf(x);
rotateLeft(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
}
} else {
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == leftOf(parentOf(x))) {
x = parentOf(x);
rotateRight(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));
}
}
}
root.color = BLACK;
}由于每个新插入的节点都是叶子节点，故而颜色都应该是红色的，而其父节点的颜色则应该是黑色的。上面代码中不断进行迭代操作，直到父节点的颜色变成黑色为止。
红黑树的右旋代码:
private void rotateRight(Entry<K,V> p) {
if (p != null) {
Entry<K,V> l = p.left;
p.left = l.right;
if (l.right != null) l.right.parent = p;
l.parent = p.parent;
if (p.parent == null)
root = l;
else if (p.parent.right == p)
p.parent.right = l;
else p.parent.left = l;
l.right = p;
p.parent = l;
}
}左旋代码类似，省略。TreeMap的核心代码就是红黑树的状态调整部分，其余的删除节点等实现的原理也是类似的。