1,概述
我们大学里学习的数据结构中的二叉树知识应用到了TreeMap中,回忆下TreeMap包含几个重要的成员变量: root, size, comparator。root 是红黑数的根节点。它是Entry类型,Entry是红黑数的节点,它包含了红 黑数的6个基本组成成分:key(键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜 色)。Entry节点根据key进行排序,Entry节点包含的内容为value。reeMap 是一个有序的key-value集合,它是通过红黑树(二叉树)实现的。
TreeMap 继承于AbstractMap,所以它是一个Map,即一个key-value集合。
TreeMap 实现了NavigableMap接口,意味着它支持一系列的导航方法。比如返回有序的key集合。
TreeMap 实现了Cloneable接口,意味着它能被克隆。
TreeMap 实现了java.io.Serializable接口,意味着它支持序列化。
案例:
public static void main(String[] args) {
Map<String,String> treeMap = new TreeMap<String,String>();
treeMap.put("93", "化学");
treeMap.put("98", "数学");
treeMap.put("92", "生物");
for(Map.Entry<String, String> en :treeMap.entrySet()) {
System.out.println(en.getKey()+":"+en.getValue());
}
}
排序了,因为分数是String类型,String实现了 Comparable<String>接口
我们也可以自定义对象实现Comparable<String>接口,可以按照我们自定义对象的属性值大小进行排序
我们还可以给treeMap传递也给比较器对象(自定义一个类实现Comparator接口), Comparator实现的比较器提供 可插拔的功能效果。
案例:public static void main(String[] args) {
Comparator<Object> comparator = new Comparator<Object>() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof TUser && o2 instanceof TUser) {
TUser user1 = (TUser) o1;
TUser user2 = (TUser) o2;
return user1.getAge()-user2.getAge();
}
return 0;
}
};
Map<Object,Object> treeMap = new TreeMap<Object,Object>(comparator);
TUser user1 = new TUser();
user1.setAge(3);
user1.setLoginName("tom");
TUser user2 = new TUser();
user2.setAge(1);
user2.setLoginName("peter");
TUser user3 = new TUser();
user3.setAge(2);
user3.setLoginName("marry");
treeMap.put(user1, user1.getAge());
treeMap.put(user2, user2.getAge());
treeMap.put(user3, user3.getAge());
for(Map.Entry<Object, Object> en :treeMap.entrySet()) {
System.out.println(en.getKey().toString()+":"+en.getValue().toString());
}
}
2,设计原理
从图中可以看出:
(1)TreeMap实现继承于AbstractMap,并且实现了NavigableMap接口。
(2)TreeMap的本质是R-B Tree(红黑树),它包含几个重要的成员变量: root, size, comparator。
root 是红黑数的根节点。它是Entry类型,Entry是红黑数的节点,它包含了红黑数的6个基本组成成分:key (键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜色)。Entry节点根据key进行 排序,Entry节点包含的内容为value。
红黑数排序时,根据Entry中的key进行排序;Entry中的key比较大小是根据比较器comparator来进行判断 的。
size是红黑数中节点的个数。
3,源码分析
TreeMap提供了操作“key”、“key-value”、“value”等方法,也提供了对TreeMap这颗树进行整体操作的方法,如 获取子树、反向树。
3.1 构造方法:
public TreeMap() { //使用节点自身的比较器(实现comparable接口)
comparator = null;
}
public TreeMap(Comparator<? super K> comparator) { //使用自定义的比较器(实现comparator接口)
this.comparator = comparator;
}
//将map中的键值放到红黑树中存储,由于map中的键是乱序的,故放入到红黑树后需要重新调整树使其平衡
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}
//直接将SortedMap中的键值放到红黑树中存储,不用调整树,因为SortedMap已经对键进行了排序
public TreeMap(SortedMap<K, ? extends V> m) {
comparator = m.comparator();
try {
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
}
//如果把comparator比较器传到TreeMap中,那么就用这个比较器比较元素,如果没有传进来,则用元素自己 实现的 comparable接口中的方法compareTo来比较。
final int compare(Object k1, Object k2) {
return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
: comparator.compare((K)k1, (K)k2);
}
3.2 TreeMap添加节点方法
public V put(K key, V value) {
Entry<K,V> t = root; //root节点用于存放当前节点
if (t == null) {
compare(key, key); //这步没啥意义,感觉
root = new Entry<>(key, value, null);//将待添加的节点作为当前节点
size = 1;//此时的节点个数为1
modCount++;//记录修改次数
return null;
}
int cmp;//存放当前节点的key和待添加节点的key调用比较器的比较方法返回的结果的变量
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
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 //如果key值相同,就用当前的value替换原来的value
return t.setValue(value);
} while (t != null);
}
else { //使用节点自身的比较器
if (key == null) //TreeMap中的key不能为null
throw new NullPointerException();
@SuppressWarnings("unchecked")
//如果节点的key实现了comparable接口,那么该节点本身就是一个比较器
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++; //节点个数加1
modCount++;修改次数加1
return null;
}
3.3 这样做了其实还没有完成,因为我知道TreeMap的底层实现是红黑树,红黑树是一棵平衡排序二叉树,普通的 排序二叉树可能会出现失衡的情况,所以下一步就是要进行调整。fixAfterInsertion(e); 调整的过程务必 会涉及到红黑树的左旋、右旋、着色三个基本操作。代码如下:调整红黑树结构使其成为平衡树方法:通过 左旋、右旋、着色的方式把当前红黑树调整成一颗平衡排序二叉树。
/**
* 新增节点后的修复操作
* x 表示新增节点
*/
private void fixAfterInsertion(Entry<K,V> x) {
x.color = RED; //新增节点的颜色为红色
//循环 直到 x不是根节点,且x的父节点不为红色
while (x != null && x != root && x.parent.color == RED) {
//如果X的父节点(P)是其父节点的父节点(G)的左节点
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
//获取X的叔节点(U)
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
//如果X的叔节点(U) 为红色(情况三)
if (colorOf(y) == RED) {
//将X的父节点(P)设置为黑色
setColor(parentOf(x), BLACK);
//将X的叔节点(U)设置为黑色
setColor(y, BLACK);
//将X的父节点的父节点(G)设置红色
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
}
//如果X的叔节点(U为黑色);这里会存在两种情况(情况四、情况五)
else {
//如果X节点为其父节点(P)的右子树,则进行左旋转(情况四)
if (x == rightOf(parentOf(x))) {
//将X的父节点作为X
x = parentOf(x);
//右旋转
rotateLeft(x);
}
//(情况五)
//将X的父节点(P)设置为黑色
setColor(parentOf(x), BLACK);
//将X的父节点的父节点(G)设置红色
setColor(parentOf(parentOf(x)), RED);
//以X的父节点的父节点(G)为中心右旋转
rotateRight(parentOf(parentOf(x)));
}
}
//如果X的父节点(P)是其父节点的父节点(G)的右节点
else {
//获取X的叔节点(U)
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
//如果X的叔节点(U) 为红色(情况三)
if (colorOf(y) == RED) {
//将X的父节点(P)设置为黑色
setColor(parentOf(x), BLACK);
//将X的叔节点(U)设置为黑色
setColor(y, BLACK);
//将X的父节点的父节点(G)设置红色
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
}
//如果X的叔节点(U为黑色);这里会存在两种情况(情况四、情况五)
else {
//如果X节点为其父节点(P)的右子树,则进行左旋转(情况四)
if (x == leftOf(parentOf(x))) {
//将X的父节点作为X
x = parentOf(x);
//右旋转
rotateRight(x);
}
//(情况五)
//将X的父节点(P)设置为黑色
setColor(parentOf(x), BLACK);
//将X的父节点的父节点(G)设置红色
setColor(parentOf(parentOf(x)), RED);
//以X的父节点的父节点(G)为中心右旋转
rotateLeft(parentOf(parentOf(x)));
}
}
}
//将根节点G强制设置为黑色
root.color = BLACK;
}
左旋:rotateLeft()所谓左旋转,就是将新增节点(N)当做其父节点(P),将其父节点P当做新增节点(N)的左 子节点。即:G.left ---> N,N.left ---> P。
private void rotateLeft(Entry<K,V> p) {
if (p != null) {
//获取P的右子节点,其实这里就相当于新增节点N(情况四而言)
Entry<K,V> r = p.right;
//将R的左子树设置为P的右子树
p.right = r.left;
//若R的左子树不为空,则将P设置为R左子树的父亲
if (r.left != null)
r.left.parent = p;
//将P的父亲设置R的父亲
r.parent = p.parent;
//如果P的父亲为空,则将R设置为跟节点
if (p.parent == null)
root = r;
//如果P为其父节点(G)的左子树,则将R设置为P父节点(G)左子树
else if (p.parent.left == p)
p.parent.left = r;
//否则R设置为P的父节点(G)的右子树
else
p.parent.right = r;
//将P设置为R的左子树
r.left = p;
//将R设置为P的父节点
p.parent = r;
}
}
所谓右旋转即,P.right ---> G、G.parent ---> P。
private void rotateRight(Entry<K,V> p) {
if (p != null) {
//将L设置为P的左子树
Entry<K,V> l = p.left;
//将L的右子树设置为P的左子树
p.left = l.right;
//若L的右子树不为空,则将P设置L的右子树的父节点
if (l.right != null)
l.right.parent = p;
//将P的父节点设置为L的父节点
l.parent = p.parent;
//如果P的父节点为空,则将L设置根节点
if (p.parent == null)
root = l;
//若P为其父节点的右子树,则将L设置为P的父节点的右子树
else if (p.parent.right == p)
p.parent.right = l;
//否则将L设置为P的父节点的左子树
else
p.parent.left = l;
//将P设置为L的右子树
l.right = p;
//将L设置为P的父节点
p.parent = l;
}
}