JDK之TreeMap源码解析

刚入java不久的程序猿，对于简单的使用已毫不满足，最终为了一探究竟，翻开了JDK的源码，以下观点为自己的理解及看了多篇博客的总结，欢迎各位大神指出不对的地方，当然也欢迎和我一样刚学的同学，一起加油努力吧~~

TreeMap简述

TreeMap看名字就知道是Map家族的成员，通过key，value键值对的方式存储元素，相对于其他map，TreeMap是有序的，TreeMap的底层是由红黑树实现的，藉由LZ算法不精，红黑树相对也比较复杂，所以参考了很多资料，浅谈一下源码的剖析

TreeMap源码解析

在看源码之前，首先先大致说下树的概念。刚刚上面也说了TreeMap底层是由红黑树实现的，所以这里我们得对红黑树有个大致印象再看源码。树无非就是由根生枝生叶的一个结构，就像java里的类也是有根Object一层一层下来的，这就是普通的树，这里我们把根叫做根节点，这里有一个规则就是根节点数据会大于左子节点，小于右子节点，但是由于会一边倒，所以有了后期优化的平衡二叉树和红黑树等等，这里我们着重介绍下红黑树。

有了树的概念，下面来简单讲一下红黑树是什么，由于根节点为黑色，所以其子节点为红色，这个红色节点的子节点为黑色，依次延伸，红黑树会保持两边平衡，从任意一节点到叶子所有路径都会包含相同数量的黑色节点，红黑树会通过左旋右旋着色来重新进行结构的调整保持平衡。

简单介绍后，我们来深入一下源码

public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable{
...
}

好了简单说一下，继承AbstractMap，实现了3个接口，第一个接口过会着重讲下，后两个接口应该都不陌生了，克隆方法与序列化，下面专门把那个比较陌生的接口拿出来看看到底是干什么的，NavigableMap这个接口继承了SortedMap，所以我们先看下SortedMap接口里定义了哪些方法

public interface SortedMap<K,V> extends Map<K,V> {
/**
* 根据key进行排序的方法
*/
Comparator<? super K> comparator();

/**
* 将fromKey到toKey进行排序
*/
SortedMap<K,V> subMap(K fromKey, K toKey);

/**
* 将小于toKey的key进行排序
*/
SortedMap<K,V> headMap(K toKey);

/**
* 将大于fromKey的key进行排序
*/
SortedMap<K,V> tailMap(K fromKey);

/**
* 返回第一个key值
*/
K firstKey();

/**
* 返回最后一个key值
*/
K lastKey();

/**
* 获得所有的key
*/
Set<K> keySet();

/**
* 获得所有的value
*/
Collection<V> values();

/**
* 将key，value转换为Set类型
*/
Set<Map.Entry<K, V>> entrySet();
}

好了，看了上面的接口，我们来看下NavigableMap这个接口里新增的方法

public interface NavigableMap<K,V> extends SortedMap<K,V> {
/**
* 返回最大key值且key值小于参数key的entry
*/
Map.Entry<K,V> lowerEntry(K key);

/**
* 返回最大key值且key值小于参数key
*/
K lowerKey(K key);

/**
* 返回最大key值且key值 <= 参数key的entry
*/
Map.Entry<K,V> floorEntry(K key);

/**
* 返回最大key值且key值 <= 参数key的key值
*/
K floorKey(K key);

/**
* 返回最小key值且key值 >= 参数key的entry
*/
Map.Entry<K,V> ceilingEntry(K key);

/**
* 返回最小key值且key值 >= 参数key的key值
*/
K ceilingKey(K key);

/**
* 返回最小key值且key值 > 参数key的entry
*/
Map.Entry<K,V> higherEntry(K key);

/**
* 返回最小key值且key值 > 参数key的key值
*/
K higherKey(K key);

/**
* 返回最小key值的entry
*/
Map.Entry<K,V> firstEntry();

/**
* 返回最大key值的entry
*/
Map.Entry<K,V> lastEntry();

/**
* 移除最小key值的entry
*/
Map.Entry<K,V> pollFirstEntry();

/**
* 移除最大key值的entry
*/
Map.Entry<K,V> pollLastEntry();

/**
* 返回一个顺序反转后的Map
*/
NavigableMap<K,V> descendingMap();

/**
* 返回包含所有key的set集合，正常排序
*/
NavigableSet<K> navigableKeySet();

/**
* 返回包含所有key的set集合，顺序为反转排序
*/
NavigableSet<K> descendingKeySet();

/**
* 返回key值在fromKey到toKey之间的Map
*/
NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
K toKey,   boolean toInclusive);

/**
* 返回key值 <= toKey的Map
*/
NavigableMap<K,V> headMap(K toKey, boolean inclusive);

/**
* 返回key值 >= fromKey的Map
*/
NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);

/**
* 等同于subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
*/
SortedMap<K,V> subMap(K fromKey, K toKey);

/**
* 等同于headMap(K toKey, boolean inclusive)
*/
SortedMap<K,V> headMap(K toKey);

/**
* 等同于tailMap(K fromKey, boolean inclusive)
*/
SortedMap<K,V> tailMap(K fromKey);
}

看了一下接口的方法，感觉用处很相似，返回的都是key值排序后其中的key或entry，这边也没太多说的，知道每个方法干什么的就行，下面开始正式的看TreeMap的源码，首先我们来了解一下很重要的一个内部类

static final class Entry<K,V> implements Map.Entry<K,V> {
//key值
K key;
//value值
V value;
//左子节点
Entry<K,V> left = null;
//右子节点
Entry<K,V> right = null;
//父节点
Entry<K,V> parent;
//节点颜色，黑色
boolean color = BLACK;

/**
* 创建新的entry，并赋予初始值
*/
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}

/**
* 返回entry的key值
*/
public K getKey() {
return key;
}

/**
* 返回value值
*/
public V getValue() {
return value;
}

/**
* 设置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;
}

//toString打印方法
public String toString() {
return key + "=" + value;
}
}

上面的entry很重要，毕竟是由一个个节点构成的，所以我们要了解它的组成，下面看一下TreeMap的全局变量

/**
* 比较器，用来对key值进行比较排序，如为null，则采用默认的
*/
private final Comparator<? super K> comparator;

/**
* 用来存放entry的
*/
private transient Entry<K,V> root = null;

/**
* entry的数量
*/
private transient int size = 0;

/**
* 修改次数
*/
private transient int modCount = 0;

TreeMap的全局变量就这些，也都比较简单，comparator一个用来排序的，TreeMap之所以有序就是这个的作用了，其他的都比较简单，下面我们继续看构造函数

/**
* TreeMap无参构造，使用默认的比较
*/
public TreeMap() {
comparator = null;
}

/**
* 参数为comparator，用给出的比较器进行排序
*/
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}

/**
* 将整个map放入TreeMap中
*/
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}

/**
* 创建一个新的TreeMap，包含传入参数map，排序方法相同
*/
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) {
}
}

/**
* 将整个map放入TreeMap中
*/
public void putAll(Map<? extends K, ? extends V> map) {
//map大小
int mapSize = map.size();
//判断TreeMap无entry，传入参数元素不为0并且传入后map是SortedMap子类
if (size==0 && mapSize!=0 && map instanceof SortedMap) {
//获得其比较器
Comparator c = ((SortedMap)map).comparator();
//条件比较器地址相同或者值相同
if (c == comparator || (c != null && c.equals(comparator))) {
++modCount;
try {
buildFromSorted(mapSize, map.entrySet().iterator(),
null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
return;
}
}
//调用父类putAll方法
super.putAll(map);
}

上面是TreeMap的几个构造方法，开篇说了由于红黑树相对比较复杂，所以这里我就挑一些常用的方法进行学习理解，如果有感兴趣的同学可以翻开源码深钻一下，应该可以收获很多，下面我们来看看一些常用的方法。

/**
* 返回键值对个数
*/
public int size() {
return size;
}

/**
* 根据key获取value
*/
public V get(Object key) {
Entry<K,V> p = getEntry(key);
return (p==null ? null : p.value);
}

/**
* 根据key获取value具体实现
*/
final Entry<K,V> getEntry(Object key) {
// 比较器存在时，调用getEntryUsingComparator方法
if (comparator != null)
return getEntryUsingComparator(key);
//key为空，抛出异常
if (key == null)
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
//获取根节点
Entry<K,V> p = root;
//遍历节点
while (p != null) {
//把遍历出的节点key与key进行比较
int cmp = k.compareTo(p.key);
//key小于当前节点key时，p左子节点移动到p位置
if (cmp < 0)
p = p.left;
//key大于当前节点key时，p右子节点移动到p位置
else if (cmp > 0)
p = p.right;
else
return p;
}
return null;
}

/**
* 比较器存在时，调用的方法
*/
final Entry<K,V> getEntryUsingComparator(Object key) {
K k = (K) key;
Comparator<? super K> cpr = comparator;
//比较器不为空时进入
if (cpr != null) {
//获取根节点
Entry<K,V> p = root;
//根节点不为空时进入
while (p != null) {
//比较两个key返回结果
int cmp = cpr.compare(k, p.key);
//结果小于0，p移动到左子节点
if (cmp < 0)
p = p.left;
//结果大于0，p移动到右子节点
else if (cmp > 0)
p = p.right;
else
return p;
}
}
return null;
}

上面介绍了get的时候，TreeMap内部是如何去操作的，接下来看看put

/**
* key，value的形式向TreeMap中放值
*/
public V put(K key, V value) {
//根节点
Entry<K,V> t = root;
//根节点为空时进入
if (t == null) {
//比较key值，这里注释为类型检测
compare(key, key); // type (and possibly null) check

//新建节点，并修改size
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
//比较后的返回值
int cmp;
//父节点
Entry<K,V> parent;
//比较器存在与不存在时分别做处理
Comparator<? super K> cpr = comparator;
if (cpr != null) {
//比较器存在时，遍历根节点
do {
//更改父节点
parent = t;
//将需要put的key与遍历出节点的key做比较
cmp = cpr.compare(key, t.key);
//当参数key大于节点key时，t的左子节点代替t节点
if (cmp < 0)
t = t.left;
//当参数key小于节点key时，t的右子节点代替t节点
else if (cmp > 0)
t = t.right;
else
//赋值并返回旧的value值
return t.setValue(value);
} while (t != null);
}
else {
//参数key为空抛出异常
if (key == null)
throw new NullPointerException();
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
Entry<K,V> e = new Entry<>(key, value, parent);
//如新增节点key小于parent的key时，作为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;

//循环，条件为x不为空，x不是父节点，x父节点颜色为红色，满足后跳出循环
while (x != null && x != root && x.parent.color == RED) {
/**
* parentOf(x)父节点
* leftOf(parentOf(parentOf(x)))父节点的父节点的左子节点
* 相等时进入
*/
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
//获取父节点的父节点的右子节点
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
//如果当y节点为红色
if (colorOf(y) == RED) {
//设置父节点颜色为黑色
setColor(parentOf(x), BLACK);
//设置y节点为黑色
setColor(y, BLACK);
//设置父节点的父节点的颜色为红色
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
//当x为其父节点的右子节点
if (x == rightOf(parentOf(x))) {
//将x的父节点作为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 rotateLeft(Entry<K,V> p) {
if (p != null) {
//获取p的右子节点
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设置为根节点，否则将r设为p的父节点的子节点
if (p.parent == null)
root = r;
else if (p.parent.left == p)
p.parent.left = r;
else
p.parent.right = r;
r.left = p;
p.parent = r;
}
}

/** 右旋方法 */
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;
}
}

在这里将右旋方法贴出，与左旋类似就不详细说明了，相信大家应该都能看懂。到这里基本上最常用的方法基本已经介绍完了，对于算法不好的LZ表示头已经快绕晕了，下面列几个简单点也能用到的方法结束TreeMap的解析

/**
* 判断是否包含此key
*/
public boolean containsKey(Object key) {
return getEntry(key) != null;
}

/**
* 判断是否包含此value
*/
public boolean containsValue(Object value) {
for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e))
if (valEquals(value, e.value))
return true;
return false;
}

/**
* 根据key值删除entry
*/
public V remove(Object key) {
//获取entry
Entry<K,V> p = getEntry(key);
if (p == null)
return null;

V oldValue = p.value;
//删除entry
deleteEntry(p);
return oldValue;
}

/**
* 清空TreeMap
*/
public void clear() {
modCount++;
size = 0;
root = null;
}

好了，没有太深入的了解TreeMap，但是主要分析了几个常用方法的实现原理，如果有感兴趣想深入的同学，可以自己看看源码，相信对算法有兴趣的朋友应该还是会喜欢的