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/p/3310928.html
第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源码代码作出分析。我们先给出源码内容，后面再对源码进行详细说明，当然，源码内容中也包含了详细的代码注释。读者阅读的时候，建议先看后面的说明，先建立一个整体印象；之后再阅读源码。
package java.util; public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable { // 比较器。用来给TreeMap排序 private final Comparator<? super K> comparator; // TreeMap是红黑树实现的，root是红黑书的根节点 private transient Entry<K,V> root = null; // 红黑树的节点总数 private transient int size = 0; // 记录红黑树的修改次数 private transient int modCount = 0; // 默认构造函数 public TreeMap() { comparator = null; } // 带比较器的构造函数 public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; } // 带Map的构造函数，Map会成为TreeMap的子集 public TreeMap(Map<? extends K, ? extends V> m) { comparator = null; putAll(m); } // 带SortedMap的构造函数，SortedMap会成为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) { } } public int size() { return size; } // 返回TreeMap中是否保护“键(key)” public boolean containsKey(Object key) { return getEntry(key) != null; } // 返回TreeMap中是否保护"值(value)" public boolean containsValue(Object value) { // getFirstEntry() 是返回红黑树的第一个节点 // successor(e) 是获取节点e的后继节点 for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e)) if (valEquals(value, e.value)) return true; return false; } // 获取“键(key)”对应的“值(value)” public V get(Object key) { // 获取“键”为key的节点(p) Entry<K,V> p = getEntry(key); // 若节点(p)为null，返回null；否则，返回节点对应的值 return (p==null ? null : p.value); } public Comparator<? super K> comparator() { return comparator; } // 获取第一个节点对应的key public K firstKey() { return key(getFirstEntry()); } // 获取最后一个节点对应的key public K lastKey() { return key(getLastEntry()); } // 将map中的全部节点添加到TreeMap中 public void putAll(Map<? extends K, ? extends V> map) { // 获取map的大小 int mapSize = map.size(); // 如果TreeMap的大小是0,且map的大小不是0,且map是已排序的“key-value对” if (size==0 && mapSize!=0 && map instanceof SortedMap) { Comparator c = ((SortedMap)map).comparator(); // 如果TreeMap和map的比较器相等； // 则将map的元素全部拷贝到TreeMap中，然后返回！ 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; } } // 调用AbstractMap中的putAll(); // AbstractMap中的putAll()又会调用到TreeMap的put() super.putAll(map); } // 获取TreeMap中“键”为key的节点 final Entry<K,V> getEntry(Object key) { // 若“比较器”为null，则通过getEntryUsingComparator()获取“键”为key的节点 if (comparator != null) return getEntryUsingComparator(key); if (key == null) throw new NullPointerException(); Comparable<? super K> k = (Comparable<? super K>) key; // 将p设为根节点 Entry<K,V> p = root; while (p != null) { int cmp = k.compareTo(p.key); // 若“p的key” < key，则p=“p的左孩子” if (cmp < 0) p = p.left; // 若“p的key” > key，则p=“p的左孩子” else if (cmp > 0) p = p.right; // 若“p的key” = key，则返回节点p else return p; } return null; } // 获取TreeMap中“键”为key的节点(对应TreeMap的比较器不是null的情况) final Entry<K,V> getEntryUsingComparator(Object key) { K k = (K) key; Comparator<? super K> cpr = comparator; if (cpr != null) { // 将p设为根节点 Entry<K,V> p = root; while (p != null) { int cmp = cpr.compare(k, p.key); // 若“p的key” < key，则p=“p的左孩子” if (cmp < 0) p = p.left; // 若“p的key” > key，则p=“p的左孩子” else if (cmp > 0) p = p.right; // 若“p的key” = key，则返回节点p else return p; } } return null; } // 获取TreeMap中不小于key的最小的节点； // 若不存在(即TreeMap中所有节点的键都比key大)，就返回null final Entry<K,V> getCeilingEntry(K key) { Entry<K,V> p = root; while (p != null) { int cmp = compare(key, p.key); // 情况一：若“p的key” > key。 // 若 p 存在左孩子，则设 p=“p的左孩子”； // 否则，返回p if (cmp < 0) { if (p.left != null) p = p.left; else return p; // 情况二：若“p的key” < key。 } else if (cmp > 0) { // 若 p 存在右孩子，则设 p=“p的右孩子” if (p.right != null) { p = p.right; } else { // 若 p 不存在右孩子，则找出 p 的后继节点，并返回 // 注意：这里返回的 “p的后继节点”有2种可能性：第一，null；第二，TreeMap中大于key的最小的节点。 // 理解这一点的核心是，getCeilingEntry是从root开始遍历的。 // 若getCeilingEntry能走到这一步，那么，它之前“已经遍历过的节点的key”都 > key。 // 能理解上面所说的，那么就很容易明白，为什么“p的后继节点”又2种可能性了。 Entry<K,V> parent = p.parent; Entry<K,V> ch = p; while (parent != null && ch == parent.right) { ch = parent; parent = parent.parent; } return parent; } // 情况三：若“p的key” = key。 } else return p; } return null; } // 获取TreeMap中不大于key的最大的节点； // 若不存在(即TreeMap中所有节点的键都比key小)，就返回null // getFloorEntry的原理和getCeilingEntry类似，这里不再多说。 final Entry<K,V> getFloorEntry(K key) { Entry<K,V> p = root; while (p != null) { int cmp = compare(key, p.key); if (cmp > 0) { if (p.right != null) p = p.right; else return p; } else if (cmp < 0) { if (p.left != null) { p = p.left; } else { Entry<K,V> parent = p.parent; Entry<K,V> ch = p; while (parent != null && ch == parent.left) { ch = parent; parent = parent.parent; } return parent; } } else return p; } return null; } // 获取TreeMap中大于key的最小的节点。 // 若不存在，就返回null。 // 请参照getCeilingEntry来对getHigherEntry进行理解。 final Entry<K,V> getHigherEntry(K key) { Entry<K,V> p = root; while (p != null) { int cmp = compare(key, p.key); if (cmp < 0) { if (p.left != null) p = p.left; else return p; } else { if (p.right != null) { p = p.right; } else { Entry<K,V> parent = p.parent; Entry<K,V> ch = p; while (parent != null && ch == parent.right) { ch = parent; parent = parent.parent; } return parent; } } } return null; } // 获取TreeMap中小于key的最大的节点。 // 若不存在，就返回null。 // 请参照getCeilingEntry来对getLowerEntry进行理解。 final Entry<K,V> getLowerEntry(K key) { Entry<K,V> p = root; while (p != null) { int cmp = compare(key, p.key); if (cmp > 0) { if (p.right != null) p = p.right; else return p; } else { if (p.left != null) { p = p.left; } else { Entry<K,V> parent = p.parent; Entry<K,V> ch = p; while (parent != null && ch == parent.left) { ch = parent; parent = parent.parent; } return parent; } } } return null; } // 将“key, value”添加到TreeMap中 // 理解TreeMap的前提是掌握“红黑树”。 // 若理解“红黑树中添加节点”的算法，则很容易理解put。 public V put(K key, V value) { Entry<K,V> t = root; // 若红黑树为空，则插入根节点 if (t == null) { // TBD: // 5045147: (coll) Adding null to an empty TreeSet should // throw NullPointerException // // compare(key, key); // type check root = new Entry<K,V>(key, value, null); size = 1; modCount++; return null; } int cmp; Entry<K,V> parent; // split comparator and comparable paths Comparator<? super K> cpr = comparator; // 在二叉树(红黑树是特殊的二叉树)中，找到(key, value)的插入位置。 // 红黑树是以key来进行排序的，所以这里以key来进行查找。 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); } else { 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); } // 新建红黑树的节点(e) Entry<K,V> e = new Entry<K,V>(key, value, parent); if (cmp < 0) parent.left = e; else parent.right = e; // 红黑树插入节点后，不再是一颗红黑树； // 这里通过fixAfterInsertion的处理，来恢复红黑树的特性。 fixAfterInsertion(e); size++; modCount++; return null; } // 删除TreeMap中的键为key的节点，并返回节点的值 public V remove(Object key) { // 找到键为key的节点 Entry<K,V> p = getEntry(key); if (p == null) return null; // 保存节点的值 V oldValue = p.value; // 删除节点 deleteEntry(p); return oldValue; } // 清空红黑树 public void clear() { modCount++; size = 0; root = null; } // 克隆一个TreeMap，并返回Object对象 public Object clone() { TreeMap<K,V> clone = null; try { clone = (TreeMap<K,V>) super.clone(); } catch (CloneNotSupportedException e) { throw new InternalError(); } // Put clone into "virgin" state (except for comparator) clone.root = null; clone.size = 0; clone.modCount = 0; clone.entrySet = null; clone.navigableKeySet = null; clone.descendingMap = null; // Initialize clone with our mappings try { clone.buildFromSorted(size, entrySet().iterator(), null, null); } catch (java.io.IOException cannotHappen) { } catch (ClassNotFoundException cannotHappen) { } return clone; } // 获取第一个节点(对外接口)。 public Map.Entry<K,V> firstEntry() { return exportEntry(getFirstEntry()); } // 获取最后一个节点(对外接口)。 public Map.Entry<K,V> lastEntry() { return exportEntry(getLastEntry()); } // 获取第一个节点，并将改节点从TreeMap中删除。 public Map.Entry<K,V> pollFirstEntry() { // 获取第一个节点 Entry<K,V> p = getFirstEntry(); Map.Entry<K,V> result = exportEntry(p); // 删除第一个节点 if (p != null) deleteEntry(p); return result; } // 获取最后一个节点，并将改节点从TreeMap中删除。 public Map.Entry<K,V> pollLastEntry() { // 获取最后一个节点 Entry<K,V> p = getLastEntry(); Map.Entry<K,V> result = exportEntry(p); // 删除最后一个节点 if (p != null) deleteEntry(p); return result; } // 返回小于key的最大的键值对，没有的话返回null public Map.Entry<K,V> lowerEntry(K key) { return exportEntry(getLowerEntry(key)); } // 返回小于key的最大的键值对所对应的KEY，没有的话返回null public K lowerKey(K key) { return keyOrNull(getLowerEntry(key)); } // 返回不大于key的最大的键值对，没有的话返回null public Map.Entry<K,V> floorEntry(K key) { return exportEntry(getFloorEntry(key)); } // 返回不大于key的最大的键值对所对应的KEY，没有的话返回null public K floorKey(K key) { return keyOrNull(getFloorEntry(key)); } // 返回不小于key的最小的键值对，没有的话返回null public Map.Entry<K,V> ceilingEntry(K key) { return exportEntry(getCeilingEntry(key)); } // 返回不小于key的最小的键值对所对应的KEY，没有的话返回null public K ceilingKey(K key) { return keyOrNull(getCeilingEntry(key)); } // 返回大于key的最小的键值对，没有的话返回null public Map.Entry<K,V> higherEntry(K key) { return exportEntry(getHigherEntry(key)); } // 返回大于key的最小的键值对所对应的KEY，没有的话返回null public K higherKey(K key) { return keyOrNull(getHigherEntry(key)); } // TreeMap的红黑树节点对应的集合 private transient EntrySet entrySet = null; // KeySet为KeySet导航类 private transient KeySet<K> navigableKeySet = null; // descendingMap为键值对的倒序“映射” private transient NavigableMap<K,V> descendingMap = null; // 返回TreeMap的“键的集合” public Set<K> keySet() { return navigableKeySet(); } // 获取“可导航”的Key的集合 // 实际上是返回KeySet类的对象。 public NavigableSet<K> navigableKeySet() { KeySet<K> nks = navigableKeySet; return (nks != null) ? nks : (navigableKeySet = new KeySet(this)); } // 返回“TreeMap的值对应的集合” public Collection<V> values() { Collection<V> vs = values; return (vs != null) ? vs : (values = new Values()); } // 获取TreeMap的Entry的集合，实际上是返回EntrySet类的对象。 public Set<Map.Entry<K,V>> entrySet() { EntrySet es = entrySet; return (es != null) ? es : (entrySet = new EntrySet()); } // 获取TreeMap的降序Map // 实际上是返回DescendingSubMap类的对象 public NavigableMap<K, V> descendingMap() { NavigableMap<K, V> km = descendingMap; return (km != null) ? km : (descendingMap = new DescendingSubMap(this, true, null, true, true, null, true)); } // 获取TreeMap的子Map // 范围是从fromKey 到 toKey；fromInclusive是是否包含fromKey的标记，toInclusive是是否包含toKey的标记 public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) { return new AscendingSubMap(this, false, fromKey, fromInclusive, false, toKey, toInclusive); } // 获取“Map的头部” <以上是关于Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例的主要内容，如果未能解决你的问题，请参考以下文章
java集合框架源码剖析系列java源码剖析之TreeMap
Java 集合系列14之 Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)
Java 集合系列14之 Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)