襄阳网络推广公司/seo关键词怎么填

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

一、TreeMap 简单介绍

什么是Map？

　　在数组中我们通过数组下标来对数组内容进行索引的，而在Map中我们通过对象来对 对象进行索引，用来索引的对象叫做key，其对应的对象叫做value。这就是我们平时说的键值对。

什么是TreeMap？

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

　　当自定义比较器时，需要自定义类实现java.lang.Comparable接口，并重写compareTo()方法。

TreeMap与HashMap的区别：

• 数据结构不同：
  • HashMap是基于哈希表，由 数组+链表+红黑树 构成。
  • TreeMap是基于红黑树实现。
• 存储方式不同：
  • HashMap是通过key的hashcode对其内容进行快速查找。
  • TreeMap中所有的元素都保持着某种固定的顺序。
• 排列顺序：
  • HashMap存储顺序不固定。
  • TreeMap存储顺序固定，可以得到一个有序的结果集。

二、TreeMap源码分析

 1.TreeMap类继承图：

TreeMap类定义：

public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable

• TreeMap<K,V>：TreeMap是以key-value形式存储数据的。
• extends AbstractMap<K,V>：继承了AbstractMap，大大减少了实现Map接口时需要的工作量。
• implements NavigableMap<K,V>：实现了SortedMap，支持一系列的导航方法。比如返回有序的key集合。
• implements Cloneable：表明其可以调用克隆方法clone()来返回实例的field-for-field拷贝。
• implements Serializable：表明该类是可以序列化的。

2.类成员变量和静态内部类Entry：

// 比较器对象
private final Comparator<? super K> comparator;// 根节点
private transient Entry<K,V> root;// 集合大小
private transient int size = 0;// 树结构被修改的次数
private transient int modCount = 0;

　// 红黑树节点颜色
　private static final boolean RED = false;
　private static final boolean BLACK = true;

// 静态内部类用来表示节点类型
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; 
}

关键字transient的作用：

　　transient是Java语言的关键字，它被用来表示一个域中不是该对象串行化的一部分。
　　Java的 serialization 提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。
当一个对象被串行化的时候，transient型的变量值 不包括在串行化的表示中，而 非transient型的变量 是被包括进去的。

3.TreeMap的构造函数：

// 默认构造函数。使用默认比较器比较key的大小，TreeMap中的元素按照自然排序进行排列。
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) {}
}

putAll(Map<? extends K, ? extends V> map) 方法：

/*** Map中的所有元素添加到TreeMap中*/
public void putAll(Map<? extends K, ? extends V> map) {int mapSize = map.size();// TreeMap的size为0，map的size不为0，并且map是SortedMap的实例if (size==0 && mapSize!=0 && map instanceof SortedMap) {Comparator<?> c = ((SortedMap<?,?>)map).comparator();// 默认比较器等于map的比较器，或者map的比较器不为null，并且与默认比较器相等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;}}// 使用父类putAll()super.putAll(map);
}/*** Map中的所有元素添加到TreeMap中*/
public void putAll(Map<? extends K, ? extends V> m) {// 遍历map一个一个添加到TreeMap中for (Map.Entry<? extends K, ? extends V> e : m.entrySet())put(e.getKey(), e.getValue());
}

buildFromSorted(int size, Iterator<?> it, java.io.ObjectInputStream str, V defaultVal) 方法：

/*** SortedMap(有序的map)中的所有元素添加到TreeMap中*/
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);
}/*** 将map中的元素逐个添加到TreeMap中，并返回map的中间元素作为根节点*/
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 {if (hi < lo) return null;// 获取中间元素int mid = (lo + hi) >>> 1;Entry<K,V> left  = null;// 若lo小于mid，则递归调用获取(middel的)左孩子。if (lo < mid)left = buildFromSorted(level+1, lo, mid - 1, redLevel,it, str, defaultVal);// 从Iterator或stream中获取middle节点对应的key和value
    K key;V value;if (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;}} else { // use streamkey = (K) str.readObject();value = (defaultVal != null ? defaultVal : (V) str.readObject());}// 创建middle节点Entry<K,V> middle =  new Entry<>(key, value, null);// 若当前节点的深度==红色节点的深度，则将节点着色为红色if (level == redLevel)middle.color = RED;// 设置middle为left的父亲，left为middle的左孩子if (left != null) {middle.left = left;left.parent = middle;}if (mid < hi) {// 递归调用获取(middel的)右孩子Entry<K,V> right = buildFromSorted(level+1, mid+1, hi, redLevel,it, str, defaultVal);// 设置middle为right的父亲，right为middle的右孩子middle.right = right;right.parent = middle;}return middle;
}

　　添加到红黑树中时，只将level == redLevel的节点设为红色。表示第level级节点，实际上是用buildFromSorted方法转换成红黑树后 的最底端的节点(假设根节点在最上方)；只将红黑树最底端的级别 着色为红色，其余都是黑色。

4.核心方法：

红黑树相关的方法：

rotateLeft(Entry<K,V> p) 方法：

/*** 左旋*/
private void rotateLeft(Entry<K,V> p) {if (p != null) {Entry<K,V> r = p.right; // 令p节点右孩子为r节点p.right = r.left; // 令r节点的左孩子为 p节点的右孩子if (r.left != null)r.left.parent = p; // 当r节点的左孩子不为null时，令p节点为 r节点的左孩子 的父节点r.parent = p.parent; // 令p节点的父节点为 r节点的父节点if (p.parent == null)root = r; // 当p节点的父节点为null时，令r节点为根节点else if (p.parent.left == p)p.parent.left = r; // 当p节点的父节点的左孩子为p节点时，令r节点为 p节点的父节点的左孩子elsep.parent.right = r; // 当p节点的父节点的右孩子为p节点时，令r节点为 p节点的父节点的右孩子r.left = p; // 令p节点为 r节点的左孩子p.parent = r; // 令r节点为 p节点的父节点
    }
}

put(K key, V value) 方法：

/*** 插入操作*/
public V put(K key, V value) {Entry<K,V> t = root; // 获取根节点if (t == null) {compare(key, key); // 检查key的类型，是否为null
root = new Entry<>(key, value, null);size = 1;modCount++;return null;}int cmp;Entry<K,V> parent;// 获取比较器Comparator<? super K> cpr = comparator;// 比较器不为null时，即自定义了比较器if (cpr != null) {// 循环比较插入节点的key与根节点的key的大小，确定插入节点的位置，即找到插入节点的父节点do {parent = t;cmp = cpr.compare(key, t.key);if (cmp < 0)t = t.left;else if (cmp > 0)t = t.right;elsereturn t.setValue(value); // 插入节点与根节点的key的大小相同，直接覆盖} while (t != null);}// 比较器为null时，使用默认的比较器else {if (key == null)throw new NullPointerException();@SuppressWarnings("unchecked")Comparable<? super K> k = (Comparable<? super K>) key;// 循环比较插入节点的key与根节点的key的大小，确定插入节点的位置，即找到插入节点的父节点do {parent = t;cmp = k.compareTo(t.key);if (cmp < 0)t = t.left;else if (cmp > 0)t = t.right;elsereturn t.setValue(value);} while (t != null);}// 在插入节点的父节点后创建节点Entry<K,V> e = new Entry<>(key, value, parent);if (cmp < 0)parent.left = e;elseparent.right = e;// 插入修正操作，使插入节点后，TreeMap还是红黑树结构
    fixAfterInsertion(e);size++;modCount++;return null;
}

与红黑树有关的方法还有：

• 右旋-rotateRight(Entry<K,V> p)
• 插入修正为红黑树-fixAfterInsertion(Entry<K,V> x)
• 删除-deleteEntry(Entry<K,V> p)
• 删除修正为红黑树-fixAfterDeletion(Entry<K,V> x)

都是根据算法翻译成代码，具体可参考这里。

TreeMap中Entry相关的方法：

　　TreeMap的 firstEntry()、 lastEntry()、 lowerEntry()、 higherEntry()、 floorEntry()、 ceilingEntry()、 pollFirstEntry() 、 pollLastEntry() 原理类似，以下讲解firstEntry()方法。

firstEntry() 方法：

/*** 获取第一个节点*/
public Map.Entry<K,V> firstEntry() {return exportEntry(getFirstEntry());
}/*** 获取第一个节点*/
final Entry<K,V> getFirstEntry() {// 获取根节点Entry<K,V> p = root; if (p != null)while (p.left != null)p = p.left;return p;
}/*** 获取第一个节点*/
static <K,V> Map.Entry<K,V> exportEntry(TreeMap.Entry<K,V> e) {// 如果节点为null，创建AbstractMap.SimpleImmutableEntry类型的对象，并返回return (e == null) ? null :new AbstractMap.SimpleImmutableEntry<>(e);
}

public static class SimpleImmutableEntry<K,V>implements Entry<K,V>, java.io.Serializable
{private static final long serialVersionUID = 7138329143949025153L;private final K key;private final V value;public SimpleImmutableEntry(K key, V value) {this.key   = key;this.value = value;}public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {this.key   = entry.getKey();this.value = entry.getValue();}public K getKey() {return key;}public V getValue() {return value;}public V setValue(V value) {throw new UnsupportedOperationException();}public boolean equals(Object o) {if (!(o instanceof Map.Entry))return false;Map.Entry<?,?> e = (Map.Entry<?,?>)o;return eq(key, e.getKey()) && eq(value, e.getValue());}public int hashCode() {return (key   == null ? 0 :   key.hashCode()) ^(value == null ? 0 : value.hashCode());}public String toString() {return key + "=" + value;}}

　　从上面，我们可以看出 firstEntry() 和 getFirstEntry() 都是用于获取第一个节点。但是，firstEntry() 是对外接口； getFirstEntry() 是内部接口。而且，firstEntry() 是通过 getFirstEntry() 来实现的。那为什么外界不能直接调用 getFirstEntry()，而需要多此一举的调用 firstEntry() 呢?

　　这么做的目的是：防止用户修改返回的Entry。getFirstEntry()返回的Entry是可以被修改的，但是经过firstEntry()返回的Entry不能被修改，只可以读取Entry的key值和value值。因为exportEntry()方法所在类 SimpleImmutableEntry 的 setValue()方法会抛出 UnsupportedOperationException() 异常。

TreeMap中key相关方法：

　　TreeMap的firstKey()、lastKey()、lowerKey()、higherKey()、floorKey()、ceilingKey()原理都是类似的，下面以ceilingKey()来进行详细说明。

ceilingKey(K key) 方法：

/*** 获取大于/等于key的最小节点所对应的key，没有的话返回null*/
public K ceilingKey(K key) {return keyOrNull(getCeilingEntry(key));
}
/*** 寻找大于/等于key的最小节点*/
final Entry<K,V> getCeilingEntry(K key) {Entry<K,V> p = root;while (p != null) {int cmp = compare(key, p.key);// 如果根节点的key大于给定keyif (cmp < 0) {if (p.left != null)p = p.left;elsereturn p;} else if (cmp > 0) { // 如果根节点的key小于给定keyif (p.right != null) {p = p.right;} else { // 如果根节点的右孩子为nullEntry<K,V> parent = p.parent;Entry<K,V> ch = p;while (parent != null && ch == parent.right) {ch = parent;parent = parent.parent;}return parent;}} elsereturn p;}return null;
}
/*** 如果节点不为null，返回节点的key值，否则返回null*/
static <K,V> K keyOrNull(TreeMap.Entry<K,V> e) {return (e == null) ? null : e.key;
}

TreeMap中value()方法：

value() 方法返回 TreeMap中值的集合：

/*** 通过 new Values() 来实现，返回TreeMap中值的集合* Values() 是集合类Value的构造函数*/
public Collection<V> values() {Collection<V> vs = values;if (vs == null) {vs = new Values();values = vs;}return vs;
}/*** 集合类Value*/
class Values extends AbstractCollection<V> {// 返回迭代器public Iterator<V> iterator() {// iterator() 通过ValueIterator() 返回迭代器return new ValueIterator(getFirstEntry());}// 返回个数public int size() {return TreeMap.this.size();}// TreeMap的值的集合中 是否包含 对象opublic boolean contains(Object o) {return TreeMap.this.containsValue(o);}// 删除TreeMap的值的集合中的对象opublic boolean remove(Object o) {for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e)) {if (valEquals(e.getValue(), o)) {deleteEntry(e);return true;}}return false;}// 清空TreeMap的值的集合public void clear() {TreeMap.this.clear();}public Spliterator<V> spliterator() {return new ValueSpliterator<K,V>(TreeMap.this, null, null, 0, -1, 0);}
}/*** ValueIterator类实现 Iterator接口实现的next()方法*/
final class ValueIterator extends PrivateEntryIterator<V> {ValueIterator(Entry<K,V> first) {super(first);}public V next() {return nextEntry().value;}
}

/*** PrivateEntryIterator类实现 Iterator接口的hasNext()和remove()方法* ValueIterator类实现 Iterator接口实现的next()方法*/
abstract class PrivateEntryIterator<T> implements Iterator<T> {// 下一节点Entry<K,V> next;// 上一次返回的节点Entry<K,V> lastReturned;// 修改次数统计数int expectedModCount;PrivateEntryIterator(Entry<K,V> first) {expectedModCount = modCount;lastReturned = null;next = first;}// 是否存在下一个节点public final boolean hasNext() {return next != null;}// 返回下一个节点final Entry<K,V> nextEntry() {Entry<K,V> e = next;if (e == null)throw new NoSuchElementException();if (modCount != expectedModCount)throw new ConcurrentModificationException();next = successor(e);lastReturned = e;return e;}// 返回上一节点final Entry<K,V> prevEntry() {Entry<K,V> e = next;if (e == null)throw new NoSuchElementException();if (modCount != expectedModCount)throw new ConcurrentModificationException();next = predecessor(e);lastReturned = e;return e;}// 删除当前节点public void remove() {if (lastReturned == null)throw new IllegalStateException();if (modCount != expectedModCount)throw new ConcurrentModificationException();// deleted entries are replaced by their successorsif (lastReturned.left != null && lastReturned.right != null)next = lastReturned;deleteEntry(lastReturned);expectedModCount = modCount;lastReturned = null;}
}

TreeMap的entrySet()方法：

 entrySet() 方法返回 TreeMap的键值对的集合：

/*** 通过 new EntrySet() 来实现，返回TreeMap的键值对集合*/
public Set<Map.Entry<K,V>> entrySet() {EntrySet es = entrySet;return (es != null) ? es : (entrySet = new EntrySet());
}/*** EntrySet是TreeMap的所有键值对组成的集合，它的单位是单个键值对*/
class EntrySet extends AbstractSet<Map.Entry<K,V>> {// 返回迭代器public Iterator<Map.Entry<K,V>> iterator() {return new EntryIterator(getFirstEntry());}// EntrySet中是否包含 键值对Objectpublic boolean contains(Object o) {if (!(o instanceof Map.Entry))return false;Map.Entry<?,?> entry = (Map.Entry<?,?>) o;Object value = entry.getValue();Entry<K,V> p = getEntry(entry.getKey());return p != null && valEquals(p.getValue(), value);}// 删除EntrySet中的 键值对Objectpublic boolean remove(Object o) {if (!(o instanceof Map.Entry))return false;Map.Entry<?,?> entry = (Map.Entry<?,?>) o;Object value = entry.getValue();Entry<K,V> p = getEntry(entry.getKey());if (p != null && valEquals(p.getValue(), value)) {deleteEntry(p);return true;}return false;}// 返回EntrySet中元素个数public int size() {return TreeMap.this.size();}// 清空EntrySetpublic void clear() {TreeMap.this.clear();}public Spliterator<Map.Entry<K,V>> spliterator() {return new EntrySpliterator<K,V>(TreeMap.this, null, null, 0, -1, 0);}
}/*** EntryIterator类实现 Iterator接口实现的next()方法*/
final class EntryIterator extends PrivateEntryIterator<Map.Entry<K,V>> {EntryIterator(Entry<K,V> first) {super(first);}public Map.Entry<K,V> next() {return nextEntry();}
}

TreeMap实现的Cloneable接口：

TreeMap实现了Cloneable接口，即实现了clone()方法。
clone()方法的作用很简单，就是克隆一个TreeMap对象并返回。

/*** 克隆一个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 mappingstry {clone.buildFromSorted(size, entrySet().iterator(), null, null);} catch (java.io.IOException cannotHappen) {} catch (ClassNotFoundException cannotHappen) {}return clone;
}

TreeMap实现的Serializable接口：

TreeMap实现java.io.Serializable，分别实现了串行读取和写入功能：

• 串行写入函数是writeObject()，它的作用是将TreeMap的“容量和所有的Entry”都写入到输出流中。
• 串行读取函数是readObject()，它的作用是将TreeMap的“容量和所有的Entry”依次读出。

readObject() 和 writeObject() 正好是一对，通过它们，我能实现TreeMap的串行传输。

/*** java.io.Serializable的写入函数* 将TreeMap的 容量和所有的Entry 都写入到输出流中*/
private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException {// Write out the Comparator and any hidden stuff
    s.defaultWriteObject();// Write out size (number of Mappings)
    s.writeInt(size);// Write out keys and values (alternating)for (Iterator<Map.Entry<K,V>> i = entrySet().iterator(); i.hasNext(); ) {Map.Entry<K,V> e = i.next();s.writeObject(e.getKey());s.writeObject(e.getValue());}
}/*** java.io.Serializable的读取函数：根据写入方式读出* 将TreeMap的 容量和所有的Entry 依次读出*/
private void readObject(final java.io.ObjectInputStream s)throws java.io.IOException, ClassNotFoundException {// Read in the Comparator and any hidden stuff
    s.defaultReadObject();// Read in sizeint size = s.readInt();buildFromSorted(size, null, s, null);
}

三、TreeMap使用例子

1.TreeMap常用方法使用Demo：

import java.util.*;/*** @author nana* @date 2019/2/23*/
public class TreeMapDemo {public static void main(String[] args) {// 测试常用的API
        testTreeMapOrdinaryAPIs();// 测试TreeMap导航函数
        testNavigableMapAPIs();// 测试TreeMap的子Map函数
        testSubMapAPIs();}/*** 测试常用的API*/private static void testTreeMapOrdinaryAPIs() {// 生成随机数Random random = new Random();// 创建TreeMap实例TreeMap treeMap = new TreeMap();treeMap.put("one", random.nextInt(10));treeMap.put("two", random.nextInt(10));treeMap.put("three", random.nextInt(10));System.out.println("TreeMapDemo.testTreeMapOrdinaryAPIs-Begin");// 打印TreeMapSystem.out.printf("打印treeMap:\n%s\n", treeMap);;// 通过Iterator遍历key-valueIterator iterator = treeMap.entrySet().iterator();System.out.println("通过Iterator遍历key-value:");while (iterator.hasNext()) {Map.Entry entity = (Map.Entry) iterator.next();System.out.printf("%s-%s\n", entity.getKey(), entity.getValue());}// TreeMap的键值对个数System.out.printf("TreeMap的键值对个数:%s\n", treeMap.size());// 是否包含keySystem.out.println("是否包含key:");System.out.printf("是否包含key:one-%s\n", treeMap.containsKey("one"));System.out.printf("是否包含key:four-%s\n", treeMap.containsKey("four"));// 删除key对应的键值对System.out.println("删除key对应的键值对:");treeMap.remove("one");System.out.printf("删除key为one的键值对后，treeMap为:\n%s\n", treeMap);// 清空TreeMap的节点System.out.println("清空treeMap的节点:");treeMap.clear();System.out.printf("%s\n", treeMap.isEmpty() ? "treeMap is empty!" : "treeMap is not empty!");System.out.printf("%s\n", treeMap == null ? "treeMap is null!" : "treeMap is not null!");System.out.println("TreeMapDemo.testTreeMapOrdinaryAPIs-End");}/*** 测试TreeMap导航函数*/private static void testNavigableMapAPIs() {// 创建TreeMap实例，TreeMap是 NavigableMap接口的实现类NavigableMap navigableMap = new TreeMap();navigableMap.put("aaa",1);navigableMap.put("bbb",2);navigableMap.put("ccc",3);navigableMap.put("ddd",4);System.out.println("TreeMapDemo.testNavigableMapAPIs-Begin");// 打印TreeMapSystem.out.printf("打印navigableMap:\n%s\n", navigableMap);// 获取第一个key和节点System.out.printf("First key:%s\tFirst entry:%s\n", navigableMap.firstKey(), navigableMap.firstEntry());// 获取最后一个key和节点System.out.printf("Last key:%s\tLast entry:%s\n", navigableMap.lastKey(), navigableMap.lastEntry());// 获取小于/等于 key为bbb 最大的key和节点System.out.printf("Key floor before bbb:%s\t%s\n", navigableMap.floorKey("bbb"), navigableMap.floorEntry("bbb"));// 获取小于 key为bbb 最大的key和节点System.out.printf("Key lower before bbb:%s\t%s\n", navigableMap.lowerKey("bbb"), navigableMap.lowerEntry("bbb"));// 获取大于/等于 key为bbb 最大的key和节点System.out.printf("Key ceiling after bbb:%s\t%s\n", navigableMap.ceilingKey("bbb"), navigableMap.ceilingEntry("bbb"));// 获取大于 key为bbb 最大的key和节点System.out.printf("Key higher after bbb:%s\t%s\n", navigableMap.higherKey("bbb"), navigableMap.higherEntry("bbb"));System.out.println("TreeMapDemo.testNavigableMapAPIs-End");}/*** 测试TreeMap的子Map函数*/private static void testSubMapAPIs() {// 实例化TreeMap对象TreeMap treeMap = new TreeMap();treeMap.put("a",1);treeMap.put("b",2);treeMap.put("c",3);treeMap.put("d",4);System.out.println("TreeMapDemo.testSubMapAPIs-Begin");// 打印TreeMapSystem.out.printf("打印TreeMap:\n%s\n", treeMap);// 打印 key为c节点 前的节点（默认不包含c节点）System.out.printf("打印 key为c节点 前的节点（默认不包含c节点）:%s", treeMap.headMap("c"));System.out.printf("打印 key为c节点 前的节点（包含c节点）:%s\n", treeMap.headMap("c", true));System.out.printf("打印 key为c节点 前的节点（不包含c节点）:%s\n", treeMap.headMap("c", false));// 打印 key为c节点 后的节点（默认包含c节点）System.out.printf("打印 key为c节点 后的节点（默认包含c节点）:%s\n", treeMap.tailMap("c"));System.out.printf("打印 key为c节点 后的节点（包含c节点）%s\n", treeMap.tailMap("c", true));System.out.printf("打印 key为c节点 后的节点（不包含c节点）%s\n", treeMap.tailMap("c", false));// 打印 key为a与c节点 之间的节点（默认不包含c节点）System.out.printf("打印 key为a与c节点 之间的节点（默认包含c节点）:\n%s\n", treeMap.subMap("a", "c"));System.out.printf("打印 key为a与c节点 之间的节点（包含a、c节点）:\n%s\n", treeMap.subMap("a", true, "c", true));System.out.printf("打印 key为a与c节点 之间的节点（包含a节点）:\n%s\n", treeMap.subMap("a", true, "c", false));System.out.printf("打印 key为a与c节点 之间的节点（包含c节点）:\n%s\n", treeMap.subMap("a", false, "c", true));System.out.printf("打印 key为a与c节点 之间的节点（不包含a、c节点）:\n%s\n", treeMap.subMap("a", false, "c", false));// 正序打印TreeMap的keySystem.out.printf("正序打印TreeMap的key:\n%s\n", treeMap.navigableKeySet());// 倒序打印TreeMap的keySystem.out.printf("倒序打印TreeMap的key:\n%s\n", treeMap.descendingKeySet());System.out.println("TreeMapDemo.testSubMapAPIs-End");}
}

TreeMapDemo.testTreeMapOrdinaryAPIs-Begin
打印treeMap:
{one=2, three=5, two=1}
通过Iterator遍历key-value:
one-2
three-5
two-1
TreeMap的键值对个数:3
是否包含key:
是否包含key:one-true
是否包含key:four-false
删除key对应的键值对:
删除key为one的键值对后，treeMap为:
{three=5, two=1}
清空treeMap的节点:
treeMap is empty!
treeMap is not null!
TreeMapDemo.testTreeMapOrdinaryAPIs-End
TreeMapDemo.testNavigableMapAPIs-Begin
打印navigableMap:
{aaa=1, bbb=2, ccc=3, ddd=4}
First key:aaa    First entry:aaa=1
Last key:ddd    Last entry:ddd=4
Key floor before bbb:bbb    bbb=2
Key lower before bbb:aaa    aaa=1
Key ceiling after bbb:bbb    bbb=2
Key higher after bbb:ccc    ccc=3
TreeMapDemo.testNavigableMapAPIs-End
TreeMapDemo.testSubMapAPIs-Begin
打印TreeMap:
{a=1, b=2, c=3, d=4}
打印 key为c节点 前的节点（默认不包含c节点）:{a=1, b=2}打印 key为c节点 前的节点（包含c节点）:{a=1, b=2, c=3}
打印 key为c节点 前的节点（不包含c节点）:{a=1, b=2}
打印 key为c节点 后的节点（默认包含c节点）:{c=3, d=4}
打印 key为c节点 后的节点（包含c节点）{c=3, d=4}
打印 key为c节点 后的节点（不包含c节点）{d=4}
打印 key为a与c节点 之间的节点（默认包含c节点）:
{a=1, b=2}
打印 key为a与c节点 之间的节点（包含a、c节点）:
{a=1, b=2, c=3}
打印 key为a与c节点 之间的节点（包含a节点）:
{a=1, b=2}
打印 key为a与c节点 之间的节点（包含c节点）:
{b=2, c=3}
打印 key为a与c节点 之间的节点（不包含a、c节点）:
{b=2}
正序打印TreeMap的key:
[a, b, c, d]
倒序打印TreeMap的key:
[d, c, b, a]
TreeMapDemo.testSubMapAPIs-End

2.TreeMap遍历使用Demo：

import org.springframework.util.StringUtils;import java.util.*;/*** @author nana* @date 2019/2/23*/
public class TreeMapIteratorTest {public static void main(String[] args) {// 创建treeMap对象TreeMap treeMap = treeMapTest();// 通过entrySet()遍历TreeMap的节点
        iteratorTreeMapByEntrySet(treeMap);// 通过keySet()遍历TreeMap的节点
        iteratorTreeMapByKeySet(treeMap);// 遍历TreeMap的value
        iteratorTreeMapByValue(treeMap);}/*** 创建treeMap对象* @return*/private static TreeMap treeMapTest() {String key = null;int keyValue = 0;Integer value = null;Random random = new Random();TreeMap treeMap = new TreeMap();int i = 0;while (i < 6) {// 随机获取[0,50)的整数keyValue = random.nextInt(50);key = String.valueOf(keyValue);value = random.nextInt(10);// 添加到treeMap中
            treeMap.put(key, value);i++;}return treeMap;}/*** 通过entrySet()遍历TreeMap的节点*/private static void iteratorTreeMapByEntrySet(TreeMap treeMapTest) {if (StringUtils.isEmpty(treeMapTest)) {return;}// 遍历TreeMapIterator iterator = treeMapTest.entrySet().iterator();System.out.println("通过entrySet()遍历TreeMap的节点:");while (iterator.hasNext()) {Map.Entry entry = (Map.Entry) iterator.next();System.out.printf("%s-%s\t", entry.getKey(), entry.getValue());}}/*** 通过keySet()遍历TreeMap的节点*/private static void iteratorTreeMapByKeySet(TreeMap treeMapTest) {if(StringUtils.isEmpty(treeMapTest)) {return;}String key = null;Integer value = null;Iterator iterator = treeMapTest.keySet().iterator();System.out.println("\n通过keySet()遍历TreeMap的节点:");while (iterator.hasNext()) {key = (String) iterator.next();value = (Integer) treeMapTest.get(key);System.out.printf("%s-%s\t", key, value);}}/*** 遍历TreeMap的value*/private static void iteratorTreeMapByValue(TreeMap treeMapTest) {if (treeMapTest == null) {return;}Collection collection = treeMapTest.values();Iterator iterator = collection.iterator();System.out.println("\n遍历TreeMap的value:");while (iterator.hasNext()) {System.out.printf("%s\t", iterator.next());}}}

通过entrySet()遍历TreeMap的节点:
19-0    2-7    20-1    22-0    34-3    
通过keySet()遍历TreeMap的节点:
19-0    2-7    20-1    22-0    34-3    
遍历TreeMap的value:
0    7    1    0    3