本文主要是介绍深读源码-java集合之TreeMap源码分析（一），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
简介
TreeMap使用红黑树存储元素，可以保证元素按key值的大小进行遍历。
继承体系
TreeMap实现了Map、SortedMap、NavigableMap、Cloneable、Serializable等接口。
可以看到，除了在之前HashMap里常见的继承类和接口以外，TreeMap实现了NavigableMap接口，而NavigableMap继承自SortedMap，由名字可以看出，只是一个用来实现排序的接口。而这也是为什么TreeMap能够实现排序的原因。
由于篇幅关系，将TreeMap的源码解析分为四部分，本章将对接口SortedMap、NavigableMap和TreeMap源码进行解析。
存储结构
TreeMap只使用到了红黑树，所以它的时间复杂度为O(log n)，红黑树的特性如下：
（1）节点是红色或者黑色。
（2）根节点是黑色。
（3）每个叶子节点（NIL）是黑色。（注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！）
（4）如果一个节点是红色的，则它的子节点必须是黑色的。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）
（5）从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。
关于红黑树相关知识，点击链直达《什么是红黑树》
源码解析
SortedMap接口源码解析
SortedMap规定了元素可以按key的大小来遍历，它定义了一些返回部分map的方法。
public interface SortedMap<K,V> extends Map<K,V> {// key的比较器Comparator<? super K> comparator();// 返回fromKey（包含）到toKey（不包含）之间的元素组成的子mapSortedMap<K,V> subMap(K fromKey, K toKey);// 返回小于toKey（不包含）的子mapSortedMap<K,V> headMap(K toKey);// 返回大于等于fromKey（包含）的子mapSortedMap<K,V> tailMap(K fromKey);// 返回最小的keyK firstKey();// 返回最大的keyK lastKey();// 返回key集合Set<K> keySet();// 返回value集合Collection<V> values();// 返回节点集合Set<Map.Entry<K, V>> entrySet();
}
SortedMap的接口比较简单，没有很特别的地方，唯一比较特别的就是返回Comparator这个接口，可以设想实现排序功能的秘密或许就藏在此处。下面让我们来看一下Comparator和Comparable接口，两者之间有点关联，可以理解为Comparable自带了比较功能，而Comparator是赋予没有比较能力的对象一种比较能力。举个简单例子：面对一道计算题，小明天生口算能力很强，看一眼就能算出来答案。而小李没有这种能力，需要借助计算器才能得出答案。
Comparable接口
public interface Comparable<T> {//如果小于o，返回负数；等于o，返回0；大于o返回正数。public int compareTo(T o);
}对，就是这么简单，里面传入一个泛型T的对象o，对o进行比较。如果小于o，返回负数；等于o，返回0；大于o返回正数。
我们熟悉的很多对象如String，Integer，Double等都实现了这个接口。可以来看一下简单的例子：
public class Item implements Comparable<Item> {private String name;private int price;public Item(String name, int price) {this.name = name;this.price = price;}public int getPrice() {return price;}public String getName() {return name;}@Overridepublic String toString() {return "Item{" +"name='" + name + '\'' +", price=" + price +'}';}@Overridepublic int compareTo(Item o) {if (this.name.compareTo(o.name) < 0) {return -1;} else if (this.name.compareTo(o.name) > 0) {return 1;} else {return 0;}}public static void main(String[] args) {// 对name进行排序List<Item> items = Arrays.asList(new Item("banana", 200), new Item("apple", 400));System.out.println("before:" + items);Collections.sort(items);System.out.println("after:" + items);}
}上述main函数的输出：
before:[Item{name='banana', price=200}, Item{name='apple', price=400}]
after:[Item{name='apple', price=400}, Item{name='banana', price=200}]
上面的例子中，我们自己实现了Comparable接口，比较了Item的name属性，然后通过Collections.sort对它进行了排序（值得注意的是：没有实现Comparable接口的对象不能使用该方法）。但是，如果我不想用name属性对它进行排序，想对price进行排序呢，或者先对name排序，相同的话在对price进行排序呢，用这个不就没法实现了吗。这就需要提到了下面的Comparator接口
Comparator接口
照例先来看一下代码：
@FunctionalInterface
public interface Comparator<T> {// 核心方法，用来比较两个对象，如果o1小于o2，返回负数；等于o2，返回0；大于o2返回正数int compare(T o1, T o2);// 好像很少用到，一般都用对象自带的equalsboolean equals(Object obj);/**-----------下面的都是JDK1.8新增的接口，挑几个放进去----------*///返回反向排序比较器default Comparator<T> reversed() {return Collections.reverseOrder(this);}//根据名字知道，先进行compare比较后，再进行一次比较default Comparator<T> thenComparing(Comparator<? super T> other) {Objects.requireNonNull(other);return (Comparator<T> & Serializable) (c1, c2) -> {int res = compare(c1, c2);return (res != 0) ? res : other.compare(c1, c2);};}//对int类型的key进行比较public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {Objects.requireNonNull(keyExtractor);return (Comparator<T> & Serializable)(c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));}//返回正常顺序的比较器public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;}
}一起来看一下如何使用，先来看一下JDK1.8以前的用法：
public class SimpleComparator implements Comparator<Item> {@Overridepublic int compare(Item o1, Item o2) {return o1.price - o2.price;}public static void main(String[] args) {// 对price进行排序List<Item> items = Arrays.asList(new Item("banana", 200), new Item("apple", 400), new Item("orange", 100));Collections.sort(items, new SimpleComparator());System.out.println(items);}
}上述main函数的输出是：
[Item{name='orange', price=100}, Item{name='banana', price=200}, Item{name='apple', price=400}]
JDK1.8以前的用法要自己手动实现Comparator接口，然后调用Collections.sort()，传入实现类来完成排序，非常麻烦，而JDK1.8则相对来说简单了很多：
public static void main(String[] args) {// 对price进行排序 List<Item> items = Arrays.asList(new Item("banana", 200), new Item("apple", 400), new Item("orange", 100));Collections.sort(items, Comparator.comparingInt((Item a) -> a.price));System.out.println(items);
}甚至，我们可以不使用Collections.sort：
public static void main(String[] args) {// 对price进行排序,不使用Collections.sortList<Item> items = Arrays.asList(new Item("banana", 100), new Item("orange", 100), new Item("apple", 400), new Item("orange", 50));items.sort(Comparator.comparingInt((Item a) -> a.price));System.out.println(items);// 使用上面的thenComparing，先对name排序，相同的话在对price进行排序items.sort(Comparator.comparing(Item::getName).thenComparing((Item::getPrice)));System.out.println("after using thenComparing: " + items);
}上述main函数的输出：
[Item{name='orange', price=50}, Item{name='banana', price=100}, Item{name='orange', price=100}, Item{name='apple', price=400}]
after using thenComparing: [Item{name='apple', price=400}, Item{name='banana', price=100}, Item{name='orange', price=50}, Item{name='orange', price=100}]
NavigableMap接口源码解析
NavigableMap是对SortedMap的增强，定义了一些返回离目标key最近的元素的方法。
public interface NavigableMap<K,V> extends SortedMap<K,V> {// 小于给定key的最大节点Map.Entry<K,V> lowerEntry(K key);// 小于给定key的最大keyK lowerKey(K key);// 小于等于给定key的最大节点Map.Entry<K,V> floorEntry(K key);// 小于等于给定key的最大keyK floorKey(K key);// 大于等于给定key的最小节点Map.Entry<K,V> ceilingEntry(K key);// 大于等于给定key的最小keyK ceilingKey(K key);// 大于给定key的最小节点Map.Entry<K,V> higherEntry(K key);// 大于给定key的最小keyK higherKey(K key);// 最小的节点Map.Entry<K,V> firstEntry();// 最大的节点Map.Entry<K,V> lastEntry();// 弹出最小的节点Map.Entry<K,V> pollFirstEntry();// 弹出最大的节点Map.Entry<K,V> pollLastEntry();// 返回倒序的mapNavigableMap<K,V> descendingMap();// 返回有序的key集合NavigableSet<K> navigableKeySet();// 返回倒序的key集合NavigableSet<K> descendingKeySet();// 返回从fromKey到toKey的子map，是否包含起止元素可以自己决定NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,K toKey, boolean toInclusive);// 返回小于toKey的子map，是否包含toKey自己决定NavigableMap<K,V> headMap(K toKey, boolean inclusive);// 返回大于fromKey的子map，是否包含fromKey自己决定NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);// 等价于subMap(fromKey, true, toKey, false)SortedMap<K,V> subMap(K fromKey, K toKey);// 等价于headMap(toKey, false)SortedMap<K,V> headMap(K toKey);// 等价于tailMap(fromKey, true)SortedMap<K,V> tailMap(K fromKey);
}
TreeMap源码解析
属性
/*** 比较器，如果没传则key要实现Comparable接口*/
private final Comparator<? super K> comparator;/*** 根节点*/
private transient Entry<K,V> root;/*** 元素个数*/
private transient int size = 0;/*** 修改次数*/
private transient int modCount = 0;
（1）comparator
按key的大小排序有两种方式，一种是key实现Comparable接口，一种方式通过构造方法传入比较器。
（2）root
根节点，TreeMap没有桶的概念，所有的元素都存储在一颗树中。
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;
}
构造方法
/*** 默认构造方法，key必须实现Comparable接口 */
public TreeMap() {comparator = null;
}/*** 使用传入的comparator比较两个key的大小*/
public TreeMap(Comparator<? super K> comparator) {this.comparator = comparator;
}/*** key必须实现Comparable接口，把传入map中的所有元素保存到新的TreeMap中 */
public TreeMap(Map<? extends K, ? extends V> m) {comparator = null;putAll(m);
}/*** 使用传入map的比较器，并把传入map中的所有元素保存到新的TreeMap中 */
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比较器，一类是key必须实现Comparable接口。
其实，笔者认为这两种比较方式可以合并成一种，当没有传comparator的时候，可以用以下方式来给comparator赋值，这样后续所有的比较操作都可以使用一样的逻辑处理了，而不用每次都检查comparator为空的时候又用Comparable来实现一遍逻辑。
// 如果comparator为空，则key必须实现Comparable接口，所以这里肯定可以强转
// 这样在构造方法中统一替换掉，后续的逻辑就都一致了
comparator = (k1, k2) -> ((Comparable<? super K>)k1).compareTo(k2);
下面让我们来看一下这个buildFromSorted方法：
/**
* size: map里键值对的数量
* it: 传入的map的entries迭代器
* str: 如果不为空，则从流里读取key-value
* defaultVal：见名知意，不为空，则value都用这个值
*/
private void buildFromSorted(int size, Iterator<?> it,java.io.ObjectInputStream str,V defaultVal)throws java.io.IOException, ClassNotFoundException {this.size = size;root = buildFromSorted(0, 0, size-1, computeRedLevel(size),it, str, defaultVal);
}我们先来分析一下computeRedLevel方法：
private static int computeRedLevel(int sz) {int level = 0;for (int m = sz - 1; m >= 0; m = m / 2 - 1)level++;return level;
}它的作用是用来计算完全二叉树的层数。什么意思呢，先来看一下下面的图：
把根结点索引看为0，那么高度为2的树的最后一个节点的索引为2，类推高度为3的最后一个节点为6，满足m = (m + 1) * 2。那么计算这个高度有什么好处呢，如上图，如果一个树有9个节点，那么我们构造红黑树的时候，只要把前面3层的结点都设置为黑色，第四层的节点设置为红色，则构造完的树，就是红黑树，满足前面提到的红黑树的5个条件。而实现的关键就是找到要构造树的完全二叉树的层数。
了解了上面的原理，后面就简单了，接着来看buildFromSorted方法：
/**
* level: 当前树的层数，注意：是从0层开始
* lo: 子树第一个元素的索引
* hi: 子树最后一个元素的索引
* redLevel: 上述红节点所在层数
* 剩下的3个就不解释了，跟上面的一样
*/
@SuppressWarnings("unchecked")
private final Entry<K,V> buildFromSorted(int level, int lo, int hi,int redLevel,Iterator<?> it,java.io.ObjectInputStream str,V defaultVal)throws java.io.IOException, ClassNotFoundException {// hi >= lo 说明子树已经构造完成if (hi < lo) return null;// 取中间位置，无符号右移，相当于除2int mid = (lo + hi) >>> 1;Entry<K,V> left = null;//递归构造左结点if (lo < mid)left = buildFromSorted(level+1, lo, mid - 1, redLevel,it, str, defaultVal);K key;V value;// 通过迭代器获取key， valueif (it != null) {if (defaultVal==null) {Map.Entry<?,?> entry = (Map.Entry<?,?>)it.next();key = (K)entry.getKey();value = (V)entry.getValue();} else {key = (K)it.next();value = defaultVal;}// 通过流来读取key, value} else {key = (K) str.readObject();value = (defaultVal != null ? defaultVal : (V) str.readObject());}//构建结点Entry<K,V> middle = new Entry<>(key, value, null);// level从0开始的，所以上述9个节点，计算出来的是3，实际上就是代表的第4层if (level == redLevel)middle.color = RED;//如果存在的话，设置左结点，if (left != null) {middle.left = left;left.parent = middle;}// 递归构造右结点if (mid < hi) {Entry<K,V> right = buildFromSorted(level+1, mid+1, hi, redLevel,it, str, defaultVal);middle.right = right;right.parent = middle;}return middle;
}get(Object key)方法
获取元素，典型的二叉查找树的查找方法。
public V get(Object key) {// 根据key查找元素Entry<K,V> p = getEntry(key);// 找到了返回value值，没找到返回nullreturn (p==null ? null : p.value);
}final Entry<K,V> getEntry(Object key) {// 如果comparator不为空，使用comparator的版本获取元素if (comparator != null)return getEntryUsingComparator(key);// 如果key为空返回空指针异常if (key == null)throw new NullPointerException();// 将key强转为Comparable@SuppressWarnings("unchecked")Comparable<? super K> k = (Comparable<? super K>) key;// 从根元素开始遍历Entry<K,V> p = root;while (p != null) {int cmp = k.compareTo(p.key);if (cmp < 0)// 如果小于0从左子树查找p = p.left;else if (cmp > 0)// 如果大于0从右子树查找p = p.right;else// 如果相等说明找到了直接返回return p;}// 没找到返回nullreturn null;
}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)// 如果小于0从左子树查找p = p.left;else if (cmp > 0)// 如果大于0从右子树查找p = p.right;else// 如果相等说明找到了直接返回return p;}}// 没找到返回nullreturn null;
}
（1）从root遍历整个树；
（2）如果待查找的key比当前遍历的key小，则在其左子树中查找；
（3）如果待查找的key比当前遍历的key大，则在其右子树中查找；
（4）如果待查找的key与当前遍历的key相等，则找到了该元素，直接返回；
（5）从这里可以看出是否有comparator分化成了两个方法，但是内部逻辑一模一样，因此可见笔者comparator = (k1, k2) -> ((Comparable<? super K>)k1).compareTo(k2);这种改造的必要性。
红黑树特性再回顾
（1）节点是红色或者黑色。
（2）根节点是黑色。
（3）每个叶子节点（NIL）是黑色。（注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！）
（4）如果一个节点是红色的，则它的子节点必须是黑色的。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）
（5）从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。
左旋
左旋，就是以某个节点为支点向左旋转。
整个左旋过程如下：
（1）将 y的左节点 设为 x的右节点，即将 β 设为 x的右节点；
（2）将 x 设为 y的左节点的父节点，即将 β的父节点 设为 x；
（3）将 x的父节点 设为 y的父节点；
（4）如果 x的父节点 为空节点，则将y设置为根节点；如果x是它父节点的左（右）节点，则将y设置为x父节点的左（右）节点；
（5）将 x 设为 y的左节点；
（6）将 x的父节点 设为 y；
让我们来看看TreeMap中的实现：
/*** 以p为支点进行左旋* 假设p为图中的x*/
private void rotateLeft(Entry<K,V> p) {if (p != null) {// p的右节点，即yEntry<K,V> r = p.right;// （1）将 y的左节点 设为 x的右节点p.right = r.left;// （2）将 x 设为 y的左节点的父节点（如果y的左节点存在的话）if (r.left != null)r.left.parent = p;// （3）将 x的父节点 设为 y的父节点r.parent = p.parent;// （4）...if (p.parent == null)// 如果 x的父节点 为空，则将y设置为根节点root = r;else if (p.parent.left == p)// 如果x是它父节点的左节点，则将y设置为x父节点的左节点p.parent.left = r;else// 如果x是它父节点的右节点，则将y设置为x父节点的右节点p.parent.right = r;// （5）将 x 设为 y的左节点r.left = p;// （6）将 x的父节点 设为 yp.parent = r;}
}
右旋
右旋，就是以某个节点为支点向右旋转。
整个右旋过程如下：
（1）将 x的右节点 设为 y的左节点，即 将 β 设为 y的左节点；
（2）将 y 设为 x的右节点的父节点，即 将 β的父节点 设为 y；
（3）将 y的父节点 设为 x的父节点；
（4）如果 y的父节点 是 空节点，则将x设为根节点；如果y是它父节点的左（右）节点，则将x设为y的父节点的左（右）节点；
（5）将 y 设为 x的右节点；
（6）将 y的父节点 设为 x；
让我们来看看TreeMap中的实现：
/*** 以p为支点进行右旋* 假设p为图中的y*/
private void rotateRight(Entry<K,V> p) {if (p != null) {// p的左节点，即xEntry<K,V> l = p.left;// （1）将 x的右节点 设为 y的左节点p.left = l.right;// （2）将 y 设为 x的右节点的父节点（如果x有右节点的话）if (l.right != null) l.right.parent = p;// （3）将 y的父节点 设为 x的父节点l.parent = p.parent;// （4）...if (p.parent == null)// 如果 y的父节点 是 空节点，则将x设为根节点root = l;else if (p.parent.right == p)// 如果y是它父节点的右节点，则将x设为y的父节点的右节点p.parent.right = l;else// 如果y是它父节点的左节点，则将x设为y的父节点的左节点p.parent.left = l;// （5）将 y 设为 x的右节点l.right = p;// （6）将 y的父节点 设为 xp.parent = l;}
}
未完待续，下一节我们一起探讨红黑树插入元素的操作。
参考链接：https://www.cnblogs.com/tong-yuan/p/10651637.html
参考链接：https://www.cnblogs.com/joemsu/p/7879726.html
这篇关于深读源码-java集合之TreeMap源码分析（一）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
