简介
TreeMap集合是基于红黑树（Red-Black tree）的 NavigableMap实现。该集合最重要的特点就是可排序，该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序。Tree两张实现排序方法，一种方式是实现java.lang.Comparable接口，并实现其compareTo()方法。第二种方式是单独写一个类去实现java.util.Comparator接口，并实现compare()方法，然后创建实例并作为TreeMap的构造方法参数进行传参
TreeMap 类
public class TreeMap<K,V> extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable
这里有个特殊接口NavigableMap
NavigableMap 接口
public interface NavigableMap<K,V> extends SortedMap<K,V>
NavigableMap 方法
// 找到第一个比指定的key小的值
Map.Entry<K,V> lowerEntry(K key);
// 找到第一个比指定的key小的key
K lowerKey(K key);
// 找到第一个小于或等于指定key的值
Map.Entry<K,V> floorEntry(K key);
// 找到第一个小于或等于指定key的key
K floorKey(K key);
// 找到第一个大于或等于指定key的值
Map.Entry<K,V> ceilingEntry(K key);
// 找到第一个大于或等于指定key的key
K ceilingKey(K key);
// 找到第一个大于指定key的值
Map.Entry<K,V> higherEntry(K key);
//找到第一个大于指定key的key
K higherKey(K key);
// 获取最小值
Map.Entry<K,V> firstEntry();
// 获取最大值
Map.Entry<K,V> lastEntry();
// 删除最小的元素
Map.Entry<K,V> pollFirstEntry();
// 删除最大的元素
Map.Entry<K,V> pollLastEntry();
//返回一个倒序的Map
NavigableMap<K,V> descendingMap();
// 返回一个Navigable的key的集合，NavigableSet和NavigableMap类似
NavigableSet<K> navigableKeySet();
// 对上述集合倒序
NavigableSet<K> descendingKeySet();
SortedMap 接口
public interface SortedMap<K,V> extends Map<K,V>
SortedMap 方法
// 排序比较器
Comparator<? super K> comparator();
// 获取其中一段
SortedMap<K,V> subMap(K fromKey, K toKey);
// 获取小于toKey的键值对
SortedMap<K,V> headMap(K toKey);
/// 获取大于fromKey的键值对
SortedMap<K,V> tailMap(K fromKey);
// 返回此映射中当前第一个键
K firstKey();
// 返回映射中当前最后一个键
K lastKey();
// 与父接口Map中的定义一样，但有顺序
Set<K> keySet();
// 与父接口Map中的定义一样，但有顺序（根据key的顺序）
Collection<V> values();
// 与父接口Map中的定义一样，但有顺序（根据key的顺序）
Set<Map.Entry<K, V>> entrySet();
SortedMap提供了获取最大值与最小值的方法，但对于一个已经排序的数据集，除了最大值与最小值之外，我们还想对任何一个元素，找到比它小的值和比它大的值，还可以按照原有的顺序倒序排序等，这时候就可以用NavigableMap接口
TreeMap 属性
// 这是一个比较器，方便插入查找元素等操作
private final Comparator<? super K> comparator;
// 红黑树的根节点：每个节点是一个Entry
private transient Entry<K,V> root;
// 集合元素数量
private transient int size = 0;
// 集合修改的记录
private transient int modCount = 0;
TreeMap 构造函数
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没有用到数组槽，并且有一个Entry的root结点，它完全就是一颗树。
TreeMap 添加
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {//如果root为null 说明是添加第一个元素 直接实例化一个Entry 赋值给root
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;//如果root不为null，说明已存在元素
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) { //如果比较器不为null 则使用比较器
//找到元素的插入位置
do {
parent = t; //parent赋值
cmp = cpr.compare(key, t.key);
//当前key小于节点key 向左子树查找
if (cmp < 0)
t = t.left;
else if (cmp > 0)//当前key大于节点key 向右子树查找
t = t.right;
else //相等的情况下 直接更新节点值
return t.setValue(value);
} while (t != null);
}
else { //如果比较器为null 则使用默认比较器
if (key == null)//如果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;
}
红黑树逻辑有兴趣的看HashMap篇
TreeMap 重要内部类
Entry 类
static final class Entry<K,V> implements Map.Entry<K,V>
虽然TreeMap 内部结构是红黑树，但是他并没有使用使用HashMap中的TreeNode对象作为节点
Entry 属性
// 键
K key;
// 值
V value;
// 左节点
Entry<K,V> left;
// 右节点
Entry<K,V> right;
// 父节点
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方法
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;
}
Entry 自己的方法不多，维护树结构主要还是靠TreeMap，不像HashMap的TreeNode需要自己维护树结构
