public class TreeMapTest { public static void main(String[] args) { TreeMap<String , Double> map = new TreeMap<String , Double>(); map.put("ccc" , 89.0); map.put("aaa" , 80.0); map.put("zzz" , 80.0); map.put("bbb" , 89.0); System.out.println(map); } } 

{aaa=80.0, bbb=89.0, ccc=89.0, zzz=80.0} 

红黑树
红黑树是一种自平衡排序二叉树，树中每个节点的值，都大于或等于在它的左子树中的所有节点的值，并且小于或等于在它的右子树中的所有节点的值，这确保红黑树运行时可以快速地在树中查找和定位的所需节点。

1，说一下super和extends这两个单词，super是父类，extends是继承父类，
2，？extends E意思是：“？”继承E，就是说“？”指代的是继承E的类，那么就是说？代表的是E或E的子类
3，？super E，意思就是说？是E或E的父类，
4，构造函数TreeSet(Comparator<?super E>comparator)你可以先把泛型去掉进行理解，意思就是说TreeSet(Comparator comparator)TreeSet（）这个构造函数的参数是Comparator类型的变量现在把泛型加入Comparator<?super E>comparator，其中规定的泛型就是说需要传递什么样的比较器，那么需要传递什么样的比较器呢？<?super E>就是这种类型的！就是规定的E类或者E的父类

public V put(K key, V value) { // 先以 t 保存链表的 root 节点Entry<K,V> t = root; // 如果 t==null，表明是一个空链表，即该 TreeMap 里没有任何 Entry if (t == null) { // 将新的 key-value 创建一个 Entry，并将该 Entry 作为 root root = new Entry<K,V>(key, value, null); // 设置该 Map 集合的 size 为 1，代表包含一个 Entry size = 1; // 记录修改次数为 1 modCount++; return null; } int cmp; Entry<K,V> parent; Comparator<? super K> cpr = comparator; // 如果比较器 cpr 不为 null，即表明采用定制排序if (cpr != null) { do { // 使用 parent 上次循环后的 t 所引用的 Entry parent = t; // 拿新插入 key 和 t 的 key 进行比较cmp = cpr.compare(key, t.key); // 如果新插入的 key 小于 t 的 key，t 等于 t 的左边节点if (cmp < 0) t = t.left; // 如果新插入的 key 大于 t 的 key，t 等于 t 的右边节点else if (cmp > 0) t = t.right; // 如果两个 key 相等，新的 value 覆盖原有的 value，// 并返回原有的 value 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 所引用的 Entry parent = t; // 拿新插入 key 和 t 的 key 进行比较cmp = k.compareTo(t.key); // 如果新插入的 key 小于 t 的 key，t 等于 t 的左边节点if (cmp < 0) t = t.left; // 如果新插入的 key 大于 t 的 key，t 等于 t 的右边节点else if (cmp > 0) t = t.right; // 如果两个 key 相等，新的 value 覆盖原有的 value，// 并返回原有的 value else return t.setValue(value); } while (t != null); } // 将新插入的节点作为 parent 节点的子节点Entry<K,V> e = new Entry<K,V>(key, value, parent); // 如果新插入 key 小于 parent 的 key，则 e 作为 parent 的左子节点if (cmp < 0) parent.left = e; // 如果新插入 key 小于 parent 的 key，则 e 作为 parent 的右子节点else parent.right = e; // 修复红黑树fixAfterInsertion(e);                               // ①size++; modCount++; return null; } 

 private void deleteEntry(Entry<K,V> p) { modCount++; size--; // 如果被删除节点的左子树、右子树都不为空if (p.left != null && p.right != null) { // 用 p 节点的中序后继节点代替 p 节点Entry<K,V> s = successor (p); p.key = s.key; p.value = s.value; p = s; } // 如果 p 节点的左节点存在，replacement 代表左节点；否则代表右节点。Entry<K,V> replacement = (p.left != null ? p.left : p.right); if (replacement != null) { replacement.parent = p.parent; // 如果 p 没有父节点，则 replacemment 变成父节点if (p.parent == null) root = replacement; // 如果 p 节点是其父节点的左子节点else if (p == p.parent.left) p.parent.left  = replacement; // 如果 p 节点是其父节点的右子节点else p.parent.right = replacement; p.left = p.right = p.parent = null; // 修复红黑树if (p.color == BLACK) fixAfterDeletion(replacement);       // ①
    } // 如果 p 节点没有父节点else if (p.parent == null) { root = null; } else { if (p.color == BLACK) // 修复红黑树fixAfterDeletion(p);                 // ②if (p.parent != null) { // 如果 p 是其父节点的左子节点if (p == p.parent.left) p.parent.left = null; // 如果 p 是其父节点的右子节点else if (p == p.parent.right) p.parent.right = null; p.parent = null; } } } 

public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable { // 使用 NavigableMap 的 key 来保存 Set 集合的元素private transient NavigableMap<E,Object> m; // 使用一个 PRESENT 作为 Map 集合的所有 value。private static final Object PRESENT = new Object(); // 包访问权限的构造器，以指定的 NavigableMap 对象创建 Set 集合TreeSet(NavigableMap<E,Object> m) { this.m = m; } public TreeSet()                                      // ①
    { // 以自然排序方式创建一个新的 TreeMap，// 根据该 TreeSet 创建一个 TreeSet，// 使用该 TreeMap 的 key 来保存 Set 集合的元素this(new TreeMap<E,Object>()); } public TreeSet(Comparator<? super E> comparator)     // ②
    { // 以定制排序方式创建一个新的 TreeMap，// 根据该 TreeSet 创建一个 TreeSet，// 使用该 TreeMap 的 key 来保存 Set 集合的元素this(new TreeMap<E,Object>(comparator)); } public TreeSet(Collection<? extends E> c) { // 调用①号构造器创建一个 TreeSet，底层以 TreeMap 保存集合元素this(); // 向 TreeSet 中添加 Collection 集合 c 里的所有元素
        addAll(c); } public TreeSet(SortedSet<E> s) { // 调用②号构造器创建一个 TreeSet，底层以 TreeMap 保存集合元素this(s.comparator()); // 向 TreeSet 中添加 SortedSet 集合 s 里的所有元素
        addAll(s); } //TreeSet 的其他方法都只是直接调用 TreeMap 的方法来提供实现
    ... public boolean addAll(Collection<? extends E> c) { if (m.size() == 0 && c.size() > 0 && c instanceof SortedSet && m instanceof TreeMap) { // 把 c 集合强制转换为 SortedSet 集合SortedSet<? extends E> set = (SortedSet<? extends E>) c; // 把 m 集合强制转换为 TreeMap 集合TreeMap<E,Object> map = (TreeMap<E, Object>) m; Comparator<? super E> cc = (Comparator<? super E>) set.comparator(); Comparator<? super E> mc = map.comparator(); // 如果 cc 和 mc 两个 Comparator 相等if (cc == mc || (cc != null && cc.equals(mc))) { // 把 Collection 中所有元素添加成 TreeMap 集合的 key
                map.addAllForTreeSet(set, PRESENT); return true; } } // 直接调用父类的 addAll() 方法来实现return super.addAll(c); } ... }