Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例相关的知识,希望对你有一定的参考价值。

概要

这一章,我们对TreeMap进行学习。
我们先对TreeMap有个整体认识,然后再学习它的源码,最后再通过实例来学会使用TreeMap。内容包括:
第1部分 TreeMap介绍
第2部分 TreeMap数据结构
第3部分 TreeMap源码解析(基于JDK1.6.0_45)
第4部分 TreeMap遍历方式
第5部分 TreeMap示例

转载:http://www.cnblogs.com/skywang12345/admin/EditPosts.aspx?postid=3310928

 

第1部分 TreeMap介绍

TreeMap 简介

TreeMap 是一个有序的key-value集合,它是通过红黑树实现的。
TreeMap 继承于AbstractMap,所以它是一个Map,即一个key-value集合。
TreeMap 实现了NavigableMap接口,意味着它支持一系列的导航方法。比如返回有序的key集合。
TreeMap 实现了Cloneable接口,意味着它能被克隆
TreeMap 实现了java.io.Serializable接口,意味着它支持序列化

TreeMap基于红黑树(Red-Black tree)实现。该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。
TreeMap的基本操作 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。
另外,TreeMap是非同步的。 它的iterator 方法返回的迭代器是fail-fastl的。

 

TreeMap的构造函数

技术分享
// 默认构造函数。使用该构造函数,TreeMap中的元素按照自然排序进行排列。
TreeMap()

// 创建的TreeMap包含Map
TreeMap(Map<? extends K, ? extends V> copyFrom)

// 指定Tree的比较器
TreeMap(Comparator<? super K> comparator)

// 创建的TreeSet包含copyFrom
TreeMap(SortedMap<K, ? extends V> copyFrom)
技术分享

 

TreeMap的API

技术分享
Entry<K, V>                ceilingEntry(K key)
K                          ceilingKey(K key)
void                       clear()
Object                     clone()
Comparator<? super K>      comparator()
boolean                    containsKey(Object key)
NavigableSet<K>            descendingKeySet()
NavigableMap<K, V>         descendingMap()
Set<Entry<K, V>>           entrySet()
Entry<K, V>                firstEntry()
K                          firstKey()
Entry<K, V>                floorEntry(K key)
K                          floorKey(K key)
V                          get(Object key)
NavigableMap<K, V>         headMap(K to, boolean inclusive)
SortedMap<K, V>            headMap(K toExclusive)
Entry<K, V>                higherEntry(K key)
K                          higherKey(K key)
boolean                    isEmpty()
Set<K>                     keySet()
Entry<K, V>                lastEntry()
K                          lastKey()
Entry<K, V>                lowerEntry(K key)
K                          lowerKey(K key)
NavigableSet<K>            navigableKeySet()
Entry<K, V>                pollFirstEntry()
Entry<K, V>                pollLastEntry()
V                          put(K key, V value)
V                          remove(Object key)
int                        size()
SortedMap<K, V>            subMap(K fromInclusive, K toExclusive)
NavigableMap<K, V>         subMap(K from, boolean fromInclusive, K to, boolean toInclusive)
NavigableMap<K, V>         tailMap(K from, boolean inclusive)
SortedMap<K, V>            tailMap(K fromInclusive)
技术分享

 

第2部分 TreeMap数据结构

TreeMap的继承关系

技术分享
java.lang.Object
   ?     java.util.AbstractMap<K, V>
         ?     java.util.TreeMap<K, V>

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

 

TreeMap与Map关系如下图:

技术分享

从图中可以看出:
(01) TreeMap实现继承于AbstractMap,并且实现了NavigableMap接口。
(02) 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源码解析(基于JDK1.6.0_45)

为了更了解TreeMap的原理,下面对TreeMap源码代码作出分析。我们先给出源码内容,后面再对源码进行详细说明,当然,源码内容中也包含了详细的代码注释。读者阅读的时候,建议先看后面的说明,先建立一个整体印象;之后再阅读源码。

技术分享
技术分享
   1 package java.util;
   2 
   3 public class TreeMap<K,V>
   4 extends AbstractMap<K,V>
   5 implements NavigableMap<K,V>, Cloneable, java.io.Serializable
   6 {
   7 
   8     // 比较器。用来给TreeMap排序
   9     private final Comparator<? super K> comparator;
  10 
  11     // TreeMap是红黑树实现的,root是红黑书的根节点
  12     private transient Entry<K,V> root = null;
  13 
  14     // 红黑树的节点总数
  15     private transient int size = 0;
  16 
  17     // 记录红黑树的修改次数
  18     private transient int modCount = 0;
  19 
  20     // 默认构造函数
  21     public TreeMap() {
  22         comparator = null;
  23     }
  24 
  25     // 带比较器的构造函数
  26     public TreeMap(Comparator<? super K> comparator) {
  27         this.comparator = comparator;
  28     }
  29 
  30     // 带Map的构造函数,Map会成为TreeMap的子集
  31     public TreeMap(Map<? extends K, ? extends V> m) {
  32         comparator = null;
  33         putAll(m);
  34     }
  35 
  36     // 带SortedMap的构造函数,SortedMap会成为TreeMap的子集
  37     public TreeMap(SortedMap<K, ? extends V> m) {
  38         comparator = m.comparator();
  39         try {
  40             buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
  41         } catch (java.io.IOException cannotHappen) {
  42         } catch (ClassNotFoundException cannotHappen) {
  43         }
  44     }
  45 
  46     public int size() {
  47         return size;
  48     }
  49 
  50     // 返回TreeMap中是否保护“键(key)”
  51     public boolean containsKey(Object key) {
  52         return getEntry(key) != null;
  53     }
  54 
  55     // 返回TreeMap中是否保护"值(value)"
  56     public boolean containsValue(Object value) {
  57         // getFirstEntry() 是返回红黑树的第一个节点
  58         // successor(e) 是获取节点e的后继节点
  59         for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e))
  60             if (valEquals(value, e.value))
  61                 return true;
  62         return false;
  63     }
  64 
  65     // 获取“键(key)”对应的“值(value)”
  66     public V get(Object key) {
  67         // 获取“键”为key的节点(p)
  68         Entry<K,V> p = getEntry(key);
  69         // 若节点(p)为null,返回null;否则,返回节点对应的值
  70         return (p==null ? null : p.value);
  71     }
  72 
  73     public Comparator<? super K> comparator() {
  74         return comparator;
  75     }
  76 
  77     // 获取第一个节点对应的key
  78     public K firstKey() {
  79         return key(getFirstEntry());
  80     }
  81 
  82     // 获取最后一个节点对应的key
  83     public K lastKey() {
  84         return key(getLastEntry());
  85     }
  86 
  87     // 将map中的全部节点添加到TreeMap中
  88     public void putAll(Map<? extends K, ? extends V> map) {
  89         // 获取map的大小
  90         int mapSize = map.size();
  91         // 如果TreeMap的大小是0,且map的大小不是0,且map是已排序的“key-value对”
  92         if (size==0 && mapSize!=0 && map instanceof SortedMap) {
  93             Comparator c = ((SortedMap)map).comparator();
  94             // 如果TreeMap和map的比较器相等;
  95             // 则将map的元素全部拷贝到TreeMap中,然后返回!
  96             if (c == comparator || (c != null && c.equals(comparator))) {
  97                 ++modCount;
  98                 try {
  99                     buildFromSorted(mapSize, map.entrySet().iterator(),
 100                                 null, null);
 101                 } catch (java.io.IOException cannotHappen) {
 102                 } catch (ClassNotFoundException cannotHappen) {
 103                 }
 104                 return;
 105             }
 106         }
 107         // 调用AbstractMap中的putAll();
 108         // AbstractMap中的putAll()又会调用到TreeMap的put()
 109         super.putAll(map);
 110     }
 111 
 112     // 获取TreeMap中“键”为key的节点
 113     final Entry<K,V> getEntry(Object key) {
 114         // 若“比较器”为null,则通过getEntryUsingComparator()获取“键”为key的节点
 115         if (comparator != null)
 116             return getEntryUsingComparator(key);
 117         if (key == null)
 118             throw new NullPointerException();
 119         Comparable<? super K> k = (Comparable<? super K>) key;
 120         // 将p设为根节点
 121         Entry<K,V> p = root;
 122         while (p != null) {
 123             int cmp = k.compareTo(p.key);
 124             // 若“p的key” < key,则p=“p的左孩子”
 125             if (cmp < 0)
 126                 p = p.left;
 127             // 若“p的key” > key,则p=“p的左孩子”
 128             else if (cmp > 0)
 129                 p = p.right;
 130             // 若“p的key” = key,则返回节点p
 131             else
 132                 return p;
 133         }
 134         return null;
 135     }
 136 
 137     // 获取TreeMap中“键”为key的节点(对应TreeMap的比较器不是null的情况)
 138     final Entry<K,V> getEntryUsingComparator(Object key) {
 139         K k = (K) key;
 140         Comparator<? super K> cpr = comparator;
 141         if (cpr != null) {
 142             // 将p设为根节点
 143             Entry<K,V> p = root;
 144             while (p != null) {
 145                 int cmp = cpr.compare(k, p.key);
 146                 // 若“p的key” < key,则p=“p的左孩子”
 147                 if (cmp < 0)
 148                     p = p.left;
 149                 // 若“p的key” > key,则p=“p的左孩子”
 150                 else if (cmp > 0)
 151                     p = p.right;
 152                 // 若“p的key” = key,则返回节点p
 153                 else
 154                     return p;
 155             }
 156         }
 157         return null;
 158     }
 159 
 160     // 获取TreeMap中不小于key的最小的节点;
 161     // 若不存在(即TreeMap中所有节点的键都比key大),就返回null
 162     final Entry<K,V> getCeilingEntry(K key) {
 163         Entry<K,V> p = root;
 164         while (p != null) {
 165             int cmp = compare(key, p.key);
 166             // 情况一:若“p的key” > key。
 167             // 若 p 存在左孩子,则设 p=“p的左孩子”;
 168             // 否则,返回p
 169             if (cmp < 0) {
 170                 if (p.left != null)
 171                     p = p.left;
 172                 else
 173                     return p;
 174             // 情况二:若“p的key” < key。
 175             } else if (cmp > 0) {
 176                 // 若 p 存在右孩子,则设 p=“p的右孩子”
 177                 if (p.right != null) {
 178                     p = p.right;
 179                 } else {
 180                     // 若 p 不存在右孩子,则找出 p 的后继节点,并返回
 181                     // 注意:这里返回的 “p的后继节点”有2种可能性:第一,null;第二,TreeMap中大于key的最小的节点。
 182                     //   理解这一点的核心是,getCeilingEntry是从root开始遍历的。
 183                     //   若getCeilingEntry能走到这一步,那么,它之前“已经遍历过的节点的key”都 > key。
 184                     //   能理解上面所说的,那么就很容易明白,为什么“p的后继节点”又2种可能性了。
 185                     Entry<K,V> parent = p.parent;
 186                     Entry<K,V> ch = p;
 187                     while (parent != null && ch == parent.right) {
 188                         ch = parent;
 189                         parent = parent.parent;
 190                     }
 191                     return parent;
 192                 }
 193             // 情况三:若“p的key” = key。
 194             } else
 195                 return p;
 196         }
 197         return null;
 198     }
 199 
 200     // 获取TreeMap中不大于key的最大的节点;
 201     // 若不存在(即TreeMap中所有节点的键都比key小),就返回null
 202     // getFloorEntry的原理和getCeilingEntry类似,这里不再多说。
 203     final Entry<K,V> getFloorEntry(K key) {
 204         Entry<K,V> p = root;
 205         while (p != null) {
 206             int cmp = compare(key, p.key);
 207             if (cmp > 0) {
 208                 if (p.right != null)
 209                     p = p.right;
 210                 else
 211                     return p;
 212             } else if (cmp < 0) {
 213                 if (p.left != null) {
 214                     p = p.left;
 215                 } else {
 216                     Entry<K,V> parent = p.parent;
 217                     Entry<K,V> ch = p;
 218                     while (parent != null && ch == parent.left) {
 219                         ch = parent;
 220                         parent = parent.parent;
 221                     }
 222                     return parent;
 223                 }
 224             } else
 225                 return p;
 226 
 227         }
 228         return null;
 229     }
 230 
 231     // 获取TreeMap中大于key的最小的节点。
 232     // 若不存在,就返回null。
 233     //   请参照getCeilingEntry来对getHigherEntry进行理解。
 234     final Entry<K,V> getHigherEntry(K key) {
 235         Entry<K,V> p = root;
 236         while (p != null) {
 237             int cmp = compare(key, p.key);
 238             if (cmp < 0) {
 239                 if (p.left != null)
 240                     p = p.left;
 241                 else
 242                     return p;
 243             } else {
 244                 if (p.right != null) {
 245                     p = p.right;
 246                 } else {
 247                     Entry<K,V> parent = p.parent;
 248                     Entry<K,V> ch = p;
 249                     while (parent != null && ch == parent.right) {
 250                         ch = parent;
 251                         parent = parent.parent;
 252                     }
 253                     return parent;
 254                 }
 255             }
 256         }
 257         return null;
 258     }
 259 
 260     // 获取TreeMap中小于key的最大的节点。
 261     // 若不存在,就返回null。
 262     //   请参照getCeilingEntry来对getLowerEntry进行理解。
 263     final Entry<K,V> getLowerEntry(K key) {
 264         Entry<K,V> p = root;
 265         while (p != null) {
 266             int cmp = compare(key, p.key);
 267             if (cmp > 0) {
 268                 if (p.right != null)
 269                     p = p.right;
 270                 else
 271                     return p;
 272             } else {
 273                 if (p.left != null) {
 274                     p = p.left;
 275                 } else {
 276                     Entry<K,V> parent = p.parent;
 277                     Entry<K,V> ch = p;
 278                     while (parent != null && ch == parent.left) {
 279                         ch = parent;
 280                         parent = parent.parent;
 281                     }
 282                     return parent;
 283                 }
 284             }
 285         }
 286         return null;
 287     }
 288 
 289     // 将“key, value”添加到TreeMap中
 290     // 理解TreeMap的前提是掌握“红黑树”。
 291     // 若理解“红黑树中添加节点”的算法,则很容易理解put。
 292     public V put(K key, V value) {
 293         Entry<K,V> t = root;
 294         // 若红黑树为空,则插入根节点
 295         if (t == null) {
 296         // TBD:
 297         // 5045147: (coll) Adding null to an empty TreeSet should
 298         // throw NullPointerException
 299         //
 300         // compare(key, key); // type check
 301             root = new Entry<K,V>(key, value, null);
 302             size = 1;
 303             modCount++;
 304             return null;
 305         }
 306         int cmp;
 307         Entry<K,V> parent;
 308         // split comparator and comparable paths
 309         Comparator<? super K> cpr = comparator;
 310         // 在二叉树(红黑树是特殊的二叉树)中,找到(key, value)的插入位置。
 311         // 红黑树是以key来进行排序的,所以这里以key来进行查找。
 312         if (cpr != null) {
 313             do {
 314                 parent = t;
 315                 cmp = cpr.compare(key, t.key);
 316                 if (cmp < 0)
 317                     t = t.left;
 318                 else if (cmp > 0)
 319                     t = t.right;
 320                 else
 321                     return t.setValue(value);
 322             } while (t != null);
 323         }
 324         else {
 325             if (key == null)
 326                 throw new NullPointerException();
 327             Comparable<? super K> k = (Comparable<? super K>) key;
 328             do {
 329                 parent = t;
 330                 cmp = k.compareTo(t.key);
 331                 if (cmp < 0)
 332                     t = t.left;
 333                 else if (cmp > 0)
 334                     t = t.right;
 335                 else
 336                     return t.setValue(value);
 337             } while (t != null);
 338         }
 339         // 新建红黑树的节点(e)
 340         Entry<K,V> e = new Entry<K,V>(key, value, parent);
 341         if (cmp < 0)
 342             parent.left = e;
 343         else
 344             parent.right = e;
 345         // 红黑树插入节点后,不再是一颗红黑树;
 346         // 这里通过fixAfterInsertion的处理,来恢复红黑树的特性。
 347         fixAfterInsertion(e);
 348         size++;
 349         modCount++;
 350         return null;
 351     }
 352 
 353     // 删除TreeMap中的键为key的节点,并返回节点的值
 354     public V remove(Object key) {
 355         // 找到键为key的节点
 356         Entry<K,V> p = getEntry(key);
 357         if (p == null)
 358             return null;
 359 
 360         // 保存节点的值
 361         V oldValue = p.value;
 362         // 删除节点
 363         deleteEntry(p);
 364         return oldValue;
 365     }
 366 
 367     // 清空红黑树
 368     public void clear() {
 369         modCount++;
 370         size = 0;
 371         root = null;
 372     }
 373 
 374     // 克隆一个TreeMap,并返回Object对象
 375     public Object clone() {
 376         TreeMap<K,V> clone = null;
 377         try {
 378             clone = (TreeMap<K,V>) super.clone();
 379         } catch (CloneNotSupportedException e) {
 380             throw new InternalError();
 381         }
 382 
 383         // Put clone into "virgin" state (except for comparator)
 384         clone.root = null;
 385         clone.size = 0;
 386         clone.modCount = 0;
 387         clone.entrySet = null;
 388         clone.navigableKeySet = null;
 389         clone.descendingMap = null;
 390 
 391         // Initialize clone with our mappings
 392         try {
 393             clone.buildFromSorted(size, entrySet().iterator(), null, null);
 394         } catch (java.io.IOException cannotHappen) {
 395         } catch (ClassNotFoundException cannotHappen) {
 396         }
 397 
 398         return clone;
 399     }
 400 
 401     // 获取第一个节点(对外接口)。
 402     public Map.Entry<K,V> firstEntry() {
 403         return exportEntry(getFirstEntry());
 404     }
 405 
 406     // 获取最后一个节点(对外接口)。
 407     public Map.Entry<K,V> lastEntry() {
 408         return exportEntry(getLastEntry());
 409     }
 410 
 411     // 获取第一个节点,并将改节点从TreeMap中删除。
 412     public Map.Entry<K,V> pollFirstEntry() {
 413         // 获取第一个节点
 414         Entry<K,V> p = getFirstEntry();
 415         Map.Entry<K,V> result = exportEntry(p);
 416         // 删除第一个节点
 417         if (p != null)
 418             deleteEntry(p);
 419         return result;
 420     }
 421 
 422     // 获取最后一个节点,并将改节点从TreeMap中删除。
 423     public Map.Entry<K,V> pollLastEntry() {
 424         // 获取最后一个节点
 425         Entry<K,V> p = getLastEntry();
 426         Map.Entry<K,V> result = exportEntry(p);
 427         // 删除最后一个节点
 428         if (p != null)
 429             deleteEntry(p);
 430         return result;
 431     }
 432 
 433     // 返回小于key的最大的键值对,没有的话返回null
 434     public Map.Entry<K,V> lowerEntry(K key) {
 435         return exportEntry(getLowerEntry(key));
 436     }
 437 
 438     // 返回小于key的最大的键值对所对应的KEY,没有的话返回null
 439     public K lowerKey(K key) {
 440         return keyOrNull(getLowerEntry(key));
 441     }
 442 
 443     // 返回不大于key的最大的键值对,没有的话返回null
 444     public Map.Entry<K,V> floorEntry(K key) {
 445         return exportEntry(getFloorEntry(key));
 446     }
 447 
 448     // 返回不大于key的最大的键值对所对应的KEY,没有的话返回null
 449     public K floorKey(K key) {
 450         return keyOrNull(getFloorEntry(key));
 451     }
 452 
 453     // 返回不小于key的最小的键值对,没有的话返回null
 454     public Map.Entry<K,V> ceilingEntry(K key) {
 455         return exportEntry(getCeilingEntry(key));
 456     }
 457 
 458     // 返回不小于key的最小的键值对所对应的KEY,没有的话返回null
 459     public K ceilingKey(K key) {
 460         return keyOrNull(getCeilingEntry(key));
 461     }
 462 
 463     // 返回大于key的最小的键值对,没有的话返回null
 464     public Map.Entry<K,V> higherEntry(K key) {
 465         return exportEntry(getHigherEntry(key));
 466     }
 467 
 468     // 返回大于key的最小的键值对所对应的KEY,没有的话返回null
 469     public K higherKey(K key) {
 470         return keyOrNull(getHigherEntry(key));
 471     }
 472 
 473     // TreeMap的红黑树节点对应的集合
 474     private transient EntrySet entrySet = null;
 475     // KeySet为KeySet导航类
 476     private transient KeySet<K> navigableKeySet = null;
 477     // descendingMap为键值对的倒序“映射”
 478     private transient NavigableMap<K,V> descendingMap = null;
 479 
 480     // 返回TreeMap的“键的集合”
 481     public Set<K> keySet() {
 482         return navigableKeySet();
 483     }
 484 
 485     // 获取“可导航”的Key的集合
 486     // 实际上是返回KeySet类的对象。
 487     public NavigableSet<K> navigableKeySet() {
 488         KeySet<K> nks = navigableKeySet;
 489         return (nks != null) ? nks : (navigableKeySet = new KeySet(this));
 490     }
 491 
 492     // 返回“TreeMap的值对应的集合”
 493     public Collection<V> values() {
 494         Collection<V> vs = values;
 495         return (vs != null) ? vs : (values = new Values());
 496     }
 497 
 498     // 获取TreeMap的Entry的集合,实际上是返回EntrySet类的对象。
 499     public Set<Map.Entry<K,V>> entrySet() {
 500         EntrySet es = entrySet;
 501         return (es != null) ? es : (entrySet = new EntrySet());
 502     }
 503 
 504     // 获取TreeMap的降序Map
 505     // 实际上是返回DescendingSubMap类的对象
 506     public NavigableMap<K, V> descendingMap() {
 507         NavigableMap<K, V> km = descendingMap;
 508         return (km != null) ? km :
 509             (descendingMap = new DescendingSubMap(this,
 510                                                   true, null, true,
 511                                                   true, null, true));
 512     }
 513 
 514     // 获取TreeMap的子Map
 515     // 范围是从fromKey 到 toKey;fromInclusive是是否包含fromKey的标记,toInclusive是是否包含toKey的标记
 516     public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
 517                                     K toKey,   boolean toInclusive) {
 518         return new AscendingSubMap(this,
 519                                    false, fromKey, fromInclusive,
 520                                    false, toKey,   toInclusive);
 521     }
 522 
 523     // 获取“Map的头部”
 524     // 范围从第一个节点 到 toKey, inclusive是是否包含toKey的标记
 525     public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
 526         return new AscendingSubMap(this,
 527                                    true,  null,  true,
 528                                    false, toKey, inclusive);
 529     }
 530 
 531     // 获取“Map的尾部”。
 532     // 范围是从 fromKey 到 最后一个节点,inclusive是是否包含fromKey的标记
 533     public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
 534         return new AscendingSubMap(this,
 535                                    false, fromKey, inclusive,
 536                                    true,  null,    true);
 537     }
 538 
 539     // 获取“子Map”。
 540     // 范围是从fromKey(包括) 到 toKey(不包括)
 541     public SortedMap<K,V> subMap(K fromKey, K toKey) {
 542         return subMap(fromKey, true, toKey, false);
 543     }
 544 
 545     // 获取“Map的头部”。
 546     // 范围从第一个节点 到 toKey(不包括)
 547     public SortedMap<K,V> headMap(K toKey) {
 548         return headMap(toKey, false);
 549     }
 550 
 551     // 获取“Map的尾部”。
 552     // 范围是从 fromKey(包括) 到 最后一个节点
 553     public SortedMap<K,V> tailMap(K fromKey) {
 554         return tailMap(fromKey, true);
 555     }
 556 
 557     // ”TreeMap的值的集合“对应的类,它集成于AbstractCollection
 558     class Values extends AbstractCollection<V> {
 559         // 返回迭代器
 560         public Iterator<V> iterator() {
 561             return new ValueIterator(getFirstEntry());
 562         }
 563 
 564         // 返回个数
 565         public int size() {
 566             return TreeMap.this.size();
 567         }
 568 
 569         // "TreeMap的值的集合"中是否包含"对象o"
 570         public boolean contains(Object o) {
 571             return TreeMap.this.containsValue(o);
 572         }
 573 
 574         // 删除"TreeMap的值的集合"中的"对象o"
 575         public boolean remove(Object o) {
 576             for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e)) {
 577                 if (valEquals(e.getValue(), o)) {
 578                     deleteEntry(e);
 579                     return true;
 580                 }
 581             }
 582             return false;
 583         }
 584 
 585         // 清空删除"TreeMap的值的集合"
 586         public void clear() {
 587             TreeMap.this.clear();
 588         }
 589     }
 590 
 591     // EntrySet是“TreeMap的所有键值对组成的集合”,
 592     // EntrySet集合的单位是单个“键值对”。
 593     class EntrySet extends AbstractSet<Map.Entry<K,V>> {
 594         public Iterator<Map.Entry<K,V>> iterator() {
 595             return new EntryIterator(getFirstEntry());
 596         }
 597 
 598         // EntrySet中是否包含“键值对Object”
 599         public boolean contains(Object o) {
 600             if (!(o instanceof Map.Entry))
 601                 return false;
 602             Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
 603             V value = entry.getValue();
 604             Entry<K,V> p = getEntry(entry.getKey());
 605             return p != null && valEquals(p.getValue(), value);
 606         }
 607 
 608         // 删除EntrySet中的“键值对Object”
 609         public boolean remove(Object o) {
 610             if (!(o instanceof Map.Entry))
 611                 return false;
 612             Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
 613             V value = entry.getValue();
 614             Entry<K,V> p = getEntry(entry.getKey());
 615             if (p != null && valEquals(p.getValue(), value)) {
 616                 deleteEntry(p);
 617                 return true;
 618             }
 619             return false;
 620         }
 621 
 622         // 返回EntrySet中元素个数
 623         public int size() {
 624             return TreeMap.this.size();
 625         }
 626 
 627         // 清空EntrySet
 628         public void clear() {
 629             TreeMap.this.clear();
 630         }
 631     }
 632 
 633     // 返回“TreeMap的KEY组成的迭代器(顺序)”
 634     Iterator<K> keyIterator() {
 635         return new KeyIterator(getFirstEntry());
 636     }
 637 
 638     // 返回“TreeMap的KEY组成的迭代器(逆序)”
 639     Iterator<K> descendingKeyIterator() {
 640         return new DescendingKeyIterator(getLastEntry());
 641     }
 642 
 643     // KeySet是“TreeMap中所有的KEY组成的集合”
 644     // KeySet继承于AbstractSet,而且实现了NavigableSet接口。
 645     static final class KeySet<E> extends AbstractSet<E> implements NavigableSet<E> {
 646         // NavigableMap成员,KeySet是通过NavigableMap实现的
 647         private final NavigableMap<E, Object> m;
 648         KeySet(NavigableMap<E,Object> map) { m = map; }
 649 
 650         // 升序迭代器
 651         public Iterator<E> iterator() {
 652             // 若是TreeMap对象,则调用TreeMap的迭代器keyIterator()
 653             // 否则,调用TreeMap子类NavigableSubMap的迭代器keyIterator()
 654             if (m instanceof TreeMap)
 655                 return ((TreeMap<E,Object>)m).keyIterator();
 656             else
 657                 return (Iterator<E>)(((TreeMap.NavigableSubMap)m).keyIterator());
 658         }
 659 
 660         // 降序迭代器
 661         public Iterator<E> descendingIterator() {
 662             // 若是TreeMap对象,则调用TreeMap的迭代器descendingKeyIterator()
 663             // 否则,调用TreeMap子类NavigableSubMap的迭代器descendingKeyIterator()
 664             if (m instanceof TreeMap)
 665                 return ((TreeMap<E,Object>)m).descendingKeyIterator();
 666             else
 667                 return (Iterator<E>)(((TreeMap.NavigableSubMap)m).descendingKeyIterator());
 668         }
 669 
 670         public int size() { return m.size(); }
 671         public boolean isEmpty() { return m.isEmpty(); }
 672         public boolean contains(Object o) { return m.containsKey(o); }
 673         public void clear() { m.clear(); }
 674         public E lower(E e) { return m.lowerKey(e); }
 675         public E floor(E e) { return m.floorKey(e); }
 676         public E ceiling(E e) { return m.ceilingKey(e); }
 677         public E higher(E e) { return m.higherKey(e); }
 678         public E first() { return m.firstKey(); }
 679         public E last() { return m.lastKey(); }
 680         public Comparator<? super E> comparator() { return m.comparator(); }
 681         public E pollFirst() {
 682             Map.Entry<E,Object> e = m.pollFirstEntry();
 683             return e == null? null : e.getKey();
 684         }
 685         public E pollLast() {
 686             Map.Entry<E,Object> e = m.pollLastEntry();
 687             return e == null? null : e.getKey();
 688         }
 689         public boolean remove(Object o) {
 690             int oldSize = size();
 691             m.remove(o);
 692             return size() != oldSize;
 693         }
 694         public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
 695                                       E toElement,   boolean toInclusive) {
 696             return new TreeSet<E>(m.subMap(fromElement, fromInclusive,
 697                                            toElement,   toInclusive));
 698         }
 699         public NavigableSet<E> headSet(E toElement, boolean inclusive) {
 700             return new TreeSet<E>(m.headMap(toElement, inclusive));
 701         }
 702         public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
 703             return new TreeSet<E>(m.tailMap(fromElement, inclusive));
 704         }
 705         public SortedSet<E> subSet(E fromElement, E toElement) {
 706             return subSet(fromElement, true, toElement, false);
 707         }
 708         public SortedSet<E> headSet(E toElement) {
 709             return headSet(toElement, false);
 710         }
 711         public SortedSet<E> tailSet(E fromElement) {
 712             return tailSet(fromElement, true);
 713         }
 714         public NavigableSet<E> descendingSet() {
 715             return new TreeSet(m.descendingMap());
 716         }
 717     }
 718 
 719     // 它是TreeMap中的一个抽象迭代器,实现了一些通用的接口。
 720     abstract class PrivateEntryIterator<T> implements Iterator<T> {
 721         // 下一个元素
 722         Entry<K,V> next;
 723         // 上一次返回元素
 724         Entry<K,V> lastReturned;
 725         // 期望的修改次数,用于实现fast-fail机制
 726         int expectedModCount;
 727 
 728         PrivateEntryIterator(Entry<K,V> first) {
 729             expectedModCount = modCount;
 730             lastReturned = null;
 731             next = first;
 732         }
 733 
 734         public final boolean hasNext() {
 735             return next != null;
 736         }
 737 
 738         // 获取下一个节点
 739         final Entry<K,V> nextEntry() {
 740             Entry<K,V> e = next;
 741             if (e == null)
 742                 throw new NoSuchElementException();
 743             if (modCount != expectedModCount)
 744                 throw new ConcurrentModificationException();
 745             next = successor(e);
 746             lastReturned = e;
 747             return e;
 748         }
 749 
 750         // 获取上一个节点
 751         final Entry<K,V> prevEntry() {
 752             Entry<K,V> e = next;
 753             if (e == null)
 754                 throw new NoSuchElementException();
 755             if (modCount != expectedModCount)
 756                 throw new ConcurrentModificationException();
 757             next = predecessor(e);
 758             lastReturned = e;
 759             return e;
 760         }
 761 
 762         // 删除当前节点
 763         public void remove() {
 764             if (lastReturned == null)
 765                 throw new IllegalStateException();
 766             if (modCount != expectedModCount)
 767                 throw new ConcurrentModificationException();
 768             // 这里重点强调一下“为什么当lastReturned的左右孩子都不为空时,要将其赋值给next”。
 769             // 目的是为了“删除lastReturned节点之后,next节点指向的仍然是下一个节点”。
 770             //     根据“红黑树”的特性可知:
 771             //     当被删除节点有两个儿子时。那么,首先把“它的后继节点的内容”复制给“该节点的内容”;之后,删除“它的后继节点”。
 772             //     这意味着“当被删除节点有两个儿子时,删除当前节点之后,‘新的当前节点‘实际上是‘原有的后继节点(即下一个节点)’”。
 773             //     而此时next仍然指向"新的当前节点"。也就是说next是仍然是指向下一个节点;能继续遍历红黑树。
 774             if (lastReturned.left != null && lastReturned.right != null)
 775                 next = lastReturned;
 776             deleteEntry(lastReturned);
 777             expectedModCount = modCount;
 778             lastReturned = null;
 779         }
 780     }
 781 
 782     // TreeMap的Entry对应的迭代器
 783     final class EntryIterator extends PrivateEntryIterator<Map.Entry<K,V>> {
 784         EntryIterator(Entry<K,V> first) {
 785             super(first);
 786         }
 787         public Map.Entry<K,V> next() {
 788             return nextEntry();
 789         }
 790     }
 791 
 792     // TreeMap的Value对应的迭代器
 793     final class ValueIterator extends PrivateEntryIterator<V> {
 794         ValueIterator(Entry<K,V> first) {
 795             super(first);
 796         }
 797         public V next() {
 798             return nextEntry().value;
 799         }
 800     }
 801 
 802     // reeMap的KEY组成的迭代器(顺序)
 803     final class KeyIterator extends PrivateEntryIterator<K> {
 804         KeyIterator(Entry<K,V> first) {
 805             super(first);
 806         }
 807         public K next() {
 808             return nextEntry().key;
 809         }
 810     }
 811 
 812     // TreeMap的KEY组成的迭代器(逆序)
 813     final class DescendingKeyIterator extends PrivateEntryIterator<K> {
 814         DescendingKeyIterator(Entry<K,V> first) {
 815             super(first);
 816         }
 817         public K next() {
 818             return prevEntry().key;
 819         }
 820     }
 821 
 822     // 比较两个对象的大小
 823     final int compare(Object k1, Object k2) {
 824         return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
 825             : comparator.compare((K)k1, (K)k2);
 826     }
 827 
 828     // 判断两个对象是否相等
 829     final static boolean valEquals(Object o1, Object o2) {
 830         return (o1==null ? o2==null : o1.equals(o2));
 831     }
 832 
 833     // 返回“Key-Value键值对”的一个简单拷贝(AbstractMap.SimpleImmutableEntry<K,V>对象)
 834     // 可用来读取“键值对”的值
 835     static <K,V> Map.Entry<K,V> exportEntry(TreeMap.Entry<K,V> e) {
 836         return e == null? null :
 837             new AbstractMap.SimpleImmutableEntry<K,V>(e);
 838     }
 839 
 840     // 若“键值对”不为null,则返回KEY;否则,返回null
 841     static <K,V> K keyOrNull(TreeMap.Entry<K,V> e) {
 842         return e == null? null : e.key;
 843     }
 844 
 845     // 若“键值对”不为null,则返回KEY;否则,抛出异常
 846     static <K> K key(Entry<K,?> e) {
 847         if (e==null)
 848             throw new NoSuchElementException();
 849         return e.key;
 850     }
 851 
 852     // TreeMap的SubMap,它一个抽象类,实现了公共操作。
 853     // 它包括了"(升序)AscendingSubMap"和"(降序)DescendingSubMap"两个子类。
 854     static abstract class NavigableSubMap<K,V> extends AbstractMap<K,V>
 855         implements NavigableMap<K,V>, java.io.Serializable {
 856         // TreeMap的拷贝
 857         final TreeMap<K,V> m;
 858         // lo是“子Map范围的最小值”,hi是“子Map范围的最大值”;
 859         // loInclusive是“是否包含lo的标记”,hiInclusive是“是否包含hi的标记”
 860         // fromStart是“表示是否从第一个节点开始计算”,
 861         // toEnd是“表示是否计算到最后一个节点      ”
 862         final K lo, hi;      
 863         final boolean fromStart, toEnd;
 864         final boolean loInclusive, hiInclusive;
 865 
 866         // 构造函数
 867         NavigableSubMap(TreeMap<K,V> m,
 868                         boolean fromStart, K lo, boolean loInclusive,
 869                         boolean toEnd,     K hi, boolean hiInclusive) {
 870             if (!fromStart && !toEnd) {
 871                 if (m.compare(lo, hi) > 0)
 872                     throw new IllegalArgumentException("fromKey > toKey");
 873             } else {
 874                 if (!fromStart) // type check
 875                     m.compare(lo, lo);
 876                 if (!toEnd)
 877                     m.compare(hi, hi);
 878             }
 879 
 880             this.m = m;
 881             this.fromStart = fromStart;
 882             this.lo = lo;
 883             this.loInclusive = loInclusive;
 884             this.toEnd = toEnd;
 885             this.hi = hi;
 886             this.hiInclusive = hiInclusive;
 887         }
 888 
 889         // 判断key是否太小
 890         final boolean tooLow(Object key) {
 891             // 若该SubMap不包括“起始节点”,
 892             // 并且,“key小于最小键(lo)”或者“key等于最小键(lo),但最小键却没包括在该SubMap内”
 893             // 则判断key太小。其余情况都不是太小!
 894             if (!fromStart) {
 895                 int c = m.compare(key, lo);
 896                 if (c < 0 || (c == 0 && !loInclusive))
 897                     return true;
 898             }
 899             return false;
 900         }
 901 
 902         // 判断key是否太大
 903         final boolean tooHigh(Object key) {
 904             // 若该SubMap不包括“结束节点”,
 905             // 并且,“key大于最大键(hi)”或者“key等于最大键(hi),但最大键却没包括在该SubMap内”
 906             // 则判断key太大。其余情况都不是太大!
 907             if (!toEnd) {
 908                 int c = m.compare(key, hi);
 909                 if (c > 0 || (c == 0 && !hiInclusive))
 910                     return true;
 911             }
 912             return false;
 913         }
 914 
 915         // 判断key是否在“lo和hi”开区间范围内
 916         final boolean inRange(Object key) {
 917             return !tooLow(key) && !tooHigh(key);
 918         }
 919 
 920         // 判断key是否在封闭区间内
 921         final boolean inClosedRange(Object key) {
 922             return (fromStart || m.compare(key, lo) >= 0)
 923                 && (toEnd || m.compare(hi, key) >= 0);
 924         }
 925 
 926         // 判断key是否在区间内, inclusive是区间开关标志
 927         final boolean inRange(Object key, boolean inclusive) {
 928             return inclusive ? inRange(key) : inClosedRange(key);
 929         }
 930 
 931         // 返回最低的Entry
 932         final TreeMap.Entry<K,V> absLowest() {
 933         // 若“包含起始节点”,则调用getFirstEntry()返回第一个节点
 934         // 否则的话,若包括lo,则调用getCeilingEntry(lo)获取大于/等于lo的最小的Entry;
 935         //           否则,调用getHigherEntry(lo)获取大于lo的最小Entry
 936         TreeMap.Entry<K,V> e =
 937                 (fromStart ?  m.getFirstEntry() :
 938                  (loInclusive ? m.getCeilingEntry(lo) :
 939                                 m.getHigherEntry(lo)));
 940             return (e == null || tooHigh(e.key)) ? null : e;
 941         }
 942 
 943         // 返回最高的Entry
 944         final TreeMap.Entry<K,V> absHighest() {
 945         // 若“包含结束节点”,则调用getLastEntry()返回最后一个节点
 946         // 否则的话,若包括hi,则调用getFloorEntry(hi)获取小于/等于hi的最大的Entry;
 947         //           否则,调用getLowerEntry(hi)获取大于hi的最大Entry
 948         TreeMap.Entry<K,V> e =
 949         TreeMap.Entry<K,V> e =
 950                 (toEnd ?  m.getLastEntry() :
 951                  (hiInclusive ?  m.getFloorEntry(hi) :
 952                                  m.getLowerEntry(hi)));
 953             return (e == null || tooLow(e.key)) ? null : e;
 954         }
 955 
 956         // 返回"大于/等于key的最小的Entry"
 957         final TreeMap.Entry<K,V> absCeiling(K key) {
 958             // 只有在“key太小”的情况下,absLowest()返回的Entry才是“大于/等于key的最小Entry”
 959             // 其它情况下不行。例如,当包含“起始节点”时,absLowest()返回的是最小Entry了!
 960             if (tooLow(key))
 961                 return absLowest();
 962             // 获取“大于/等于key的最小Entry”
 963         TreeMap.Entry<K,V> e = m.getCeilingEntry(key);
 964             return (e == null || tooHigh(e.key)) ? null : e;
 965         }
 966 
 967         // 返回"大于key的最小的Entry"
 968         final TreeMap.Entry<K,V> absHigher(K key) {
 969             // 只有在“key太小”的情况下,absLowest()返回的Entry才是“大于key的最小Entry”
 970             // 其它情况下不行。例如,当包含“起始节点”时,absLowest()返回的是最小Entry了,而不一定是“大于key的最小Entry”!
 971             if (tooLow(key))
 972                 return absLowest();
 973             // 获取“大于key的最小Entry”
 974         TreeMap.Entry<K,V> e = m.getHigherEntry(key);
 975             return (e == null || tooHigh(e.key)) ? null : e;
 976         }
 977 
 978         // 返回"小于/等于key的最大的Entry"
 979         final TreeMap.Entry<K,V> absFloor(K key) {
 980             // 只有在“key太大”的情况下,(absHighest)返回的Entry才是“小于/等于key的最大Entry”
 981             // 其它情况下不行。例如,当包含“结束节点”时,absHighest()返回的是最大Entry了!
 982             if (tooHigh(key))
 983                 return absHighest();
 984         // 获取"小于/等于key的最大的Entry"
 985         TreeMap.Entry<K,V> e = m.getFloorEntry(key);
 986             return (e == null || tooLow(e.key)) ? null : e;
 987         }
 988 
 989         // 返回"小于key的最大的Entry"
 990         final TreeMap.Entry<K,V> absLower(K key) {
 991             // 只有在“key太大”的情况下,(absHighest)返回的Entry才是“小于key的最大Entry”
 992             // 其它情况下不行。例如,当包含“结束节点”时,absHighest()返回的是最大Entry了,而不一定是“小于key的最大Entry”!
 993             if (tooHigh(key))
 994                 return absHighest();
 995         // 获取"小于key的最大的Entry"
 996         TreeMap.Entry<K,V> e = m.getLowerEntry(key);
 997             return (e == null || tooLow(e.key)) ? null : e;
 998         }
 999 
1000         // 返回“大于最大节点中的最小节点”,不存在的话,返回null
1001         final TreeMap.Entry<K,V> absHighFence() {
1002             return (toEnd ? null : (hiInclusive ?
1003                                     m.getHigherEntry(hi) :
1004                                     m.getCeilingEntry(hi)));
1005         }
1006 
1007         // 返回“小于最小节点中的最大节点”,不存在的话,返回null
1008         final TreeMap.Entry<K,V> absLowFence() {
1009             return (fromStart ? null : (loInclusive ?
1010                                         m.getLowerEntry(lo) :
1011                                         m.getFloorEntry(lo)));
1012         }
1013 
1014         // 下面几个abstract方法是需要NavigableSubMap的实现类实现的方法
1015         abstract TreeMap.Entry<K,V> subLowest();
1016         abstract TreeMap.Entry<K,V> subHighest();
1017         abstract TreeMap.Entry<K,V> subCeiling(K key);
1018         abstract TreeMap.Entry<K,V> subHigher(K key);
1019         abstract TreeMap.Entry<K,V> subFloor(K key);
1020         abstract TreeMap.Entry<K,V> subLower(K key);
1021         // 返回“顺序”的键迭代器
1022         abstract Iterator<K> keyIterator();
1023         // 返回“逆序”的键迭代器
1024         abstract Iterator<K> descendingKeyIterator();
1025 
1026         // 返回SubMap是否为空。空的话,返回true,否则返回false
1027         public boolean isEmpty() {
1028             return (fromStart && toEnd) ? m.isEmpty() : entrySet().isEmpty();
1029         }
1030 
1031         // 返回SubMap的大小
1032         public int size() {
1033             return (fromStart && toEnd) ? m.size() : entrySet().size();
1034         }
1035 
1036         // 返回SubMap是否包含键key
1037         public final boolean containsKey(Object key) {
1038             return inRange(key) && m.containsKey(key);
1039         }
1040 
1041         // 将key-value 插入SubMap中
1042         public final V put(K key, V value) {
1043             if (!inRange(key))
1044                 throw new IllegalArgumentException("key out of range");
1045             return m.put(key, value);
1046         }
1047 
1048         // 获取key对应值
1049         public final V get(Object key) {
1050             return !inRange(key)? null :  m.get(key);
1051         }
1052 
1053         // 删除key对应的键值对
1054         public final V remove(Object key) {
1055             return !inRange(key)? null  : m.remove(key);
1056         }
1057 
1058         // 获取“大于/等于key的最小键值对”
1059         public final Map.Entry<K,V> ceilingEntry(K key) {
1060             return exportEntry(subCeiling(key));
1061         }
1062 
1063         // 获取“大于/等于key的最小键”
1064         public final K ceilingKey(K key) {
1065             return keyOrNull(subCeiling(key));
1066         }
1067 
1068         // 获取“大于key的最小键值对”
1069         public final Map.Entry<K,V> higherEntry(K key) {
1070             return exportEntry(subHigher(key));
1071         }
1072 
1073         // 获取“大于key的最小键”
1074    

以上是关于Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例的主要内容,如果未能解决你的问题,请参考以下文章

java集合框架源码剖析系列java源码剖析之TreeMap

Java 集合系列14之 Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)

Java 集合系列14之 Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)

死磕 java集合之TreeMap源码分析

Java 集合系列06之 Vector详细介绍(源码解析)和使用示例

Java 集合系列05之 LinkedList详细介绍(源码解析)和使用示例