Java--集合--TreeSet

1. 源码解读实现配序
   1. 　执行构造方法 new TreeSet（Comparator<? super K> comparator）
      

      1. public TreeSet(Comparator<? super E> comparator) {
             this(new TreeMap<>(comparator));
         }

         
         public TreeMap(Comparator<? super K> comparator) {
                 this.comparator = comparator;
             }
         //将内名内部类的引用传给内部的Comparator变量，在我们加入元素的时候需要用到这和内部类 

   2. 执行 hashSet.add()

      1. 　

          public boolean add(E e) {
                 return m.put(e, PRESENT)==null;
             } //调用的TreeMap的put方法

      2.  public V put(K key, V value) {
                 Entry<K,V> t = root; //上一个节点，如果是第一次添加则为null
                 if (t == null) {
         //第一次添加则进入到这里
                     compare(key, key); // type (and possibly null) check
         //为元素创建节点，并加入到table中
                     root = new Entry<>(key, value, null);
                     size = 1;
                     modCount++;
                     return null;
                 }
                 int cmp;
                 Entry<K,V> parent;
                 // split comparator and comparable paths
         //将匿名内部类复制给cpr
         
                 Comparator<? super K> cpr = comparator;
         //如果cpr不为空则进行循环判断大小
                 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();
                     @SuppressWarnings("unchecked")
                         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<>(key, value, parent);
         //根据匿名内部类的放回值，调整e的位置
                 if (cmp < 0)
                     parent.left = e;
                 else
                     parent.right = e;
                 fixAfterInsertion(e);
                 size++;
                 modCount++;
                 return null;
             }