Java 集合类 TreeSet、TreeMap

TreeMap和TreeSet的异同：

相同点：

1. TreeMap和TreeSet都是有序的集合，也就是说他们存储的值都是拍好序的。

• TreeMap和TreeSet都是非同步集合，因此他们不能在多线程之间共享，不过可以使用方法Collections.synchroinzedMap()来实现同步
• 运行速度都要比Hash集合慢，他们内部对元素的操作时间复杂度为O(logN)，而HashMap/HashSet则为O(1)。

不同点：

1. 最主要的区别就是TreeSet和TreeMap非别实现Set和Map接口

• TreeSet只存储一个对象，而TreeMap存储两个对象Key和Value（仅仅key对象有序）
• TreeSet中不能有重复对象，而TreeMap中可以存在

TreeSet的是NavigableSet的实现类，NavigableSet继承了SortedSet接口，SortedSet是Set的子接口；

 1 public class TreeSet<E> extends AbstractSet<E>
 2     implements NavigableSet<E>, Cloneable, java.io.Serializable
 3 {
 4 　　/**
 5     * The backing map.
 6     */
 7 　　private transient NavigableMap<E,Object> m;
 8
 9     // Dummy value to associate with an Object in the backing Map
10     private static final Object PRESENT = new Object();
11
12 　　/**
13      * Constructs a set backed by the specified navigable map.
14      */
15     TreeSet(NavigableMap<E,Object> m) {
16         this.m = m;
17     }
18
19     /**
20      * Constructs a new, empty tree set, sorted according to the
21      * natural ordering of its elements.  All elements inserted into
22      * the set must implement the {@link Comparable} interface.
23      * Furthermore, all such elements must be <i>mutually
24      * comparable</i>: {@code e1.compareTo(e2)} must not throw a
25      * {@code ClassCastException} for any elements {@code e1} and
26      * {@code e2} in the set.  If the user attempts to add an element
27      * to the set that violates this constraint (for example, the user
28      * attempts to add a string element to a set whose elements are
29      * integers), the {@code add} call will throw a
30      * {@code ClassCastException}.
31      */
32     public TreeSet() {
33         this(new TreeMap<E,Object>());
34     }
35 　　.......
36 }

由上面的TreeSet的源码可以看出，TreeSet的底层实现是通过TreeMap实现的，而TreeMap的底层又是如何实现的呢？

 1   public TreeMap() {
 2         comparator = null;
 3   }
 4
 5  public TreeMap(Comparator<? super K> comparator) {
 6         this.comparator = comparator;
 7    }
 8 .....(其他构造方法不一一列举)
 9 //这里列举put方法详细讲解
10  public V put(K key, V value) {
11         Entry<K,V> t = root;
12         if (t == null) {
13             compare(key, key); // type (and possibly null) check
14
15             root = new Entry<>(key, value, null);
16             size = 1;
17             modCount++;
18             return null;
19         }
20         int cmp;
21         Entry<K,V> parent;
22         // split comparator and comparable paths
23         Comparator<? super K> cpr = comparator;
24         if (cpr != null) {
25             do {
26                 parent = t;
27                 cmp = cpr.compare(key, t.key);
28                 if (cmp < 0)
29                     t = t.left;
30                 else if (cmp > 0)
31                     t = t.right;
32                 else
33                     return t.setValue(value);
34             } while (t != null);
35         }
36         else {
37             if (key == null)
38                 throw new NullPointerException();
39             Comparable<? super K> k = (Comparable<? super K>) key;
40             do {
41                 parent = t;
42                 cmp = k.compareTo(t.key);
43                 if (cmp < 0)
44                     t = t.left;
45                 else if (cmp > 0)
46                     t = t.right;
47                 else
48                     return t.setValue(value);
49             } while (t != null);
50         }
51         Entry<K,V> e = new Entry<>(key, value, parent);
52         if (cmp < 0)
53             parent.left = e;
54         else
55             parent.right = e;
56         fixAfterInsertion(e);
57         size++;
58         modCount++;
59         return null;
60     }

从上面的TreeMap的两个构造方法和插入方法可以看出当第一次插入时，返回null，插入值不同时返回null；否则返回值不为null；这里需要注意以下几点：

1、创 建TreeSet或者TreeMap时候采用有参构造函数并且参数是Comparator时候，参数必须是Comparator的实现子类；而利用无参构 造函数时，向TreeSet或者TreeMap添加元素是需要特别注意所添加的对象必须是实现了Comparable接口的子类否则会报错（对象类型 cannot be cast to java.lang.Comparable），这也是TreeMap的put方法中实现的原因，这是多态的表现，父类对象指向子类引用；

Comparable<? super K> k = (Comparable<? super K>) key；

2、由于TreeSet和TreeMap的底层都是树形结构，而且每一个节点的对象是Entry对象

1         K key;
2         V value;
3         Entry<K,V> left = null;
4         Entry<K,V> right = null;
5         Entry<K,V> parent;   

这是Entry的结构，是一个类似链表节点的树形结构；

3、TreeSet和TreeMap的底层都是树形结构是一个二叉查找树，并且是一个红黑平衡树，实现方法：

 fixAfterInsertion(e);