Java集合容器系列05-TreeMap
1、TreeMap的介绍
TreeMap继承自AbstractMap，实现了NavigableMap，基于红黑树实现，它内部的键值对映射是按照类内部指定的比较器Comparator进行排序，若是内部的排序器为空则根据键值对映射中Key的天然顺序进行排序，取决于实例化对象时使用的构造函数。Treemap的底层红黑树结构保证了containKey、get、put、remove方法定位Key操做的时间复杂度为O(logN)。TreeMap是非线程安全的，在建立容器迭代器Iterator以后若是有其余线程对容器作出结构性修改（添加、插入、删除键值对均属于结构性修改，修改已存在键值对的value值不算结构性修改）会抛出一个ConcurrentModificationException异常。java
2、TreeMap的数据结构
1 - 继承结构
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable
从源码中能够看出TreeMap继承AbstractMap，AbstractMap实现了Map的一些基本操做，此外是实现了NavigableMap、Cloneable、java.io.Serializable接口。NavigableMap接口定义了一系列基于排序的导航方法例如返回lowerEntry(K key)返回key小于key且排序最接近key的对应键值对，由于间接实现了SortedMap故TreeMap的键值对按序存储。安全
2 - 内部成员变量和底层数据结构
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable
{
//key比较器
private final Comparator<? super K> comparator;
//根节点
private transient Entry<K,V> root;
//容器存储的节点个数
private transient int size = 0;
//结构化修改的次数
private transient int modCount = 0;
}
其余成员变量直接看源码注释就能够了，下面我看来看下根节点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;
}
//获取节点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;
}
public String toString() {
return key + "=" + value;
}
}
查看Entry类的内部属性咱们知道TreeMap底层是基于红黑树实现的，这里对于红黑树这种数据结构暂时不作详细分析，只要知道这是一种大体平衡的二叉树，且查询所需的时间复杂度为O(logN)app
3、TreeMap的源码解析
1 - 构造函数
public TreeMap() {
comparator = null;
}
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}
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) {
}
}
咱们依次分析一下TreeMap提供的四种构造函数。函数
1）TreeMap()ui
没作啥，把排序器comparator设置为空，comparator被final修饰且以后键值对映射排序以前须要判断comparator是否为空。this
2）TreeMap(Comparator<? super K> comparator)spa
将内部的key比较器设置为方法指定的比较器comparator线程
3）TreeMap(Map<? extends K, ? extends V> m)指针
方法入参是一个Map对象由于Map内部键值对存储不是有序的，不包含一个比较器comparator，将内部的比较器设置为null，把map对象包含的全部键值对按照Key实现的天然顺序插入TreeMap
4）TreeMap(SortedMap<K, ? extends V> m)
设置TreeMap内部比较器为SortedMap对象m内部指定的的比较器。而后按序遍历m中的全部键值对节点插入到TreeMap
2 - V get(Object key)根据key获取键值对映射value
public V get(Object key) {
Entry<K,V> p = getEntry(key);
return (p==null ? null : p.value);
}
get方法内部调用getEntry方法根据key获取TreeMap容器中保存的键值对节点p，而后判断节点p是否为空，为空返回null，不为空返回节点的value属性。咱们继续跟进getEntry(key)方法源码看下该方法内部作了什么。
final Entry<K,V> getEntry(Object key) {
//内部比较器comparator不为空，基于它指定的比较器遍历红黑树获取key对应节点
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;
//遍历TreeMap内部红黑树，基于指定对象key定义的比较函数比较指定key与节点key，获取指定key对应的节点信息
while (p != null) {
int cmp = k.compareTo(p.key);
if (cmp < 0)
//指定key小于当前节点，继续遍历当前节点的左孩子节点
p = p.left;
else if (cmp > 0)
//指定key大于当前节点，继续遍历当前节点的右孩子节点
p = p.right;
else
//相等直接返回当前节点
return p;
}
return null;
}
方法内部首先判断内部比较器comparator是否为null，不为null直接调用getEntryUsingComparator(key)使用内部指定的比较器遍历比较TreeMap内部红黑树中的键值对节点key与指定key获取指定key匹配的节点信息，咱们跟进该方法看下源码层面如何实现
final Entry<K,V> getEntryUsingComparator(Object key) {
@SuppressWarnings("unchecked")
K k = (K) key;
Comparator<? super K> cpr = comparator;
if (cpr != null) {
Entry<K,V> p = root;
while (p != null) {
int cmp = cpr.compare(k, p.key);
if (cmp < 0)
p = p.left;
else if (cmp > 0)
p = p.right;
else
return p;
}
}
return null;
}
该方法内部实现逻辑很简单，就是从根节点开始遍历内部红黑树，基于内部比较器比较指定key与当前节点的key，相等直接返回当前节点，若是指定key小于当前节点key继续遍历当前节点的左节点，不然继续遍历当前节点的右节点。遍历完成还没找到指定key对应节点信息或者内部比较器comparator为null则方法返回null。
返回上一个方法getEntry继续分析。接下来对方法入参key进行判空，若是对象为null抛出空指针异常。接下来遍历TreeMap内部红黑树从根节点开始使用指定key类内部实现的compare方法(即类天然顺序)对两个对象key和红黑树当前节点key比较，若等于表示匹配上返回当前节点，小于继续遍历左孩子节点，大于则遍历右孩子节点。
3 - V put(K key, V value)插入键值对
public V put(K key, V value) {
Entry<K,V> t = root;
//若根节点为空
if (t == null) {
//类型校验可能为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;
Comparator<? super K> cpr = comparator;
//若容器内部存在比较器，则遍历红黑树基于比较器comparator比较节点key和指定key获取指定键值对的插入节点，若该
//位置已经存在，则用新值value取代旧值
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);
}
//若比较器为空则使用指定key所属类实现的Comparable中定义的天然顺序遍历容器内部红黑树，比较节点key和指定key
//获取指定键值对的插入节点，若指定key已存在则用新值value覆盖旧值
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);
}
//建立新节点，设置双亲节点parent
Entry<K,V> e = new Entry<>(key, value, parent);
//若新插入节点的逻辑顺序小于双亲节点，则它被设置为双亲节点的左孩子
if (cmp < 0)
parent.left = e;
//不然设置为双亲节点的右孩子
else
parent.right = e;
//执行插入修正操做，保证在插入新节点以后仍然是红黑树，这里的调整操做主要包括两种1修改节点颜色；2对某些节点进
//行旋转进行旋转
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
4 - V remove(Object key)删除key对应的键值对
public V remove(Object key) {
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}
方法内部首先调用getEntry方法获取key对应的键值对节点，接着进行判空，若是返回的节点为空方法结束返回null，不然调用deleteEntry方法删除节点，返回删除节点的value。咱们进入deleteEntry方法源码看下它是如何实现的。
private void deleteEntry(Entry<K,V> p) {
//为何结构修改计数器和键值对个数size放在方法开头更新？
modCount++;
size--;
//待删除节点左右孩子节点均不为空
if (p.left != null && p.right != null) {
//获取指定节点的后继节点
Entry<K,V> s = successor(p);
p.key = s.key;
p.value = s.value;
p = s;
}
Entry<K,V> replacement = (p.left != null ? p.left : p.right);
//若删除节点左节点或者右节点不为空不为空
if (replacement != null) {
//替换节点的双亲节点指向被删除节点的双亲节点
replacement.parent = p.parent;
//被删除节点是根节点则重置根节点为替换节点
if (p.parent == null)
root = replacement;
//若被删除节点是他双亲节点的左孩子则让被删除节点的左孩子节点指向当前替换节点replacement
else if (p == p.parent.left)
p.parent.left = replacement;
//若被删除节点为双亲节点的右孩子则让被删除节点的右孩子节点指向当前节点replacement
else
p.parent.right = replacement;
// Null out links so they are OK to use by fixAfterDeletion.
p.left = p.right = p.parent = null;
//若是被删除的节点是黑色则须要执行删除后修复，保证删除节点后底层存储结构仍然是红黑树
if (p.color == BLACK)
fixAfterDeletion(replacement);
} else if (p.parent == null) {//若被删除节点是根节点，且左右孩子节点均为空，则根节点置空
root = null;
} else { //被删除节点不是根节点且左右子树均为空，由于红黑树须要知足一个节点到它的子孙节点的全部路径都包含相
//同数目的黑节点则，所以在删除以后须要判断当前节点是不是黑节点若是是则可能违反红黑树的规定，须要调用
//fixAfterDeletion执行删除后处理保证删除节点后键值对的存储结构仍然是红黑树
if (p.color == BLACK)
fixAfterDeletion(p);
//若是若被删除节点的双亲节点不为空，断开被删除节点与双亲节点的链接
if (p.parent != null) {
//若被删除节点是双亲节点的左孩子，让被删除节点的左孩子指向null
if (p == p.parent.left)
p.parent.left = null;
//若被删除节点是双亲节点的右孩子则让被删除节点的右孩子指向null
else if (p == p.parent.right)
p.parent.right = null;
//被删除节点的双亲节点指向null
p.parent = null;
}
}
}
分析当前方法结合以前的调用方方法源码咱们能够大概整理出remove方法的基本逻辑以下：
1）根据key遍历红黑树获取待删除节点，若节点为空返回null；
2）若待删除节点不为空，调用deleteEntry删除节点，若待删除节点的左右孩子节点都存在则让待删除节点的后继节点替代待删除节点，对替换以后的待删除节点分状况进行处理：
选择待删除节点的左孩子节点或右孩子节点为替代节点replacement，优先选择左孩子若左孩子不存在选择右孩子节点。
1.若替代节点replacement不为null。若待删除节点为根节点时，重置根节点为替换节点replacement；若待删除节点为双亲节点的左孩子，则让待删除节点的左孩子指向替代节点replacement，不然让它的双亲节点的右孩子指向替代节点replacement；
以后断开待删除节点与其余节点的链接释放该节点，若是删除的节点是黑色BLACK则还须要调用fixAfterDeletion方法进行节点删除后调整，保证红黑树结构不被破坏；
2.若待删除节点p是根节点，根节点置空；
3.若待删除节点不是根节点且左右子树均为空。若被删除节点颜色是黑色BLACK，由于红黑树必须保证，任意一个叶子节点到根节点的路径中包含黑色节点的个数相同，因此若被删除节点是根节点还须要调用fixAfterDeletion进行节点删除调整，断开与双亲节点的链接。
- 1. Java集合容器系列08-HashSet
- 2. Java集合容器系列04-HashMap
- 3. Java集合容器系列09 - TreeSet
- 4. Java集合容器系列02-ArrayList
- 5. Java容器（集合）
- 6. Java 集合系列 [
- 7. Java 集合系列
- 8. Java容器系列-Java容器总览
- 9. Java中各容器集合
- 10. Java 集合容器概述
- 更多相关文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • Docker容器实战(七) - 容器眼光下的文件系统
- • Docker容器实战(六) - 容器的隔离与限制
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 「插件」Runner更新Pro版，帮助设计师远离996
- 2. 错误 707 Could not load file or assembly ‘Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKe
- 3. Jenkins 2018 报告速览，Kubernetes使用率跃升235%！
- 4. TVI-Android技术篇之注解Annotation
- 5. android studio启动项目
- 6. Android的ADIL
- 7. Android卡顿的检测及优化方法汇总（线下+线上）
- 8. 登录注册的业务逻辑流程梳理
- 9. NDK(1)创建自己的C/C++文件
- 10. 小菜的系统框架界面设计-你的评估是我的决策
- 1. Java集合容器系列08-HashSet
- 2. Java集合容器系列04-HashMap
- 3. Java集合容器系列09 - TreeSet
- 4. Java集合容器系列02-ArrayList
- 5. Java容器（集合）
- 6. Java 集合系列 [
- 7. Java 集合系列
- 8. Java容器系列-Java容器总览
- 9. Java中各容器集合
- 10. Java 集合容器概述