java中的TreeSet的add()方法解析

TreeSet的add()方法解析【添加和去重】

public class HomeWork05 {
    public static void main(String[] args) {
        // TreeSet最好是同一类型。
//        TreeSet treeSet = new TreeSet();
        // TreeSet可以定义排序【匿名内部类作为参数，实现Compare接口】
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String) o1).compareTo((String) o2);
            }
        });
        treeSet.add("hello");
        treeSet.add("world");
        treeSet.add(new String("hello"));
//        treeSet.add(new A(10));
//        treeSet.add(new A(20));

        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }

        /**
         * TreeSet无参构造器：
         *     public TreeSet() {
         *         this(new TreeMap<E,Object>());
         *     }
         *     public TreeMap() {
         *         comparator = null;
         *     }
         * 可见TreeSet的底层是TreeMap。
         *
         * 解析add():
         * 1) public boolean add(E e) {
         *         return m.put(e, PRESENT)==null;
         *     }
         *     $ PRESENT是value的固定值，主要是按照key的值存储。
         *
         * 2) public V put(K key, V value) {
         *         Entry<K,V> t = root;
         *         // 首次进入put()方法，root为空
         *         // 将第一次添加的key，作为root根节点
         *         if (t == null) {
         *             compare(key, key);
         *             root = new Entry<>(key, value, null);
         *             size = 1;
         *             modCount++;
         *             return null;
         *         }
         *         int cmp;
         *         Entry<K,V> parent;
         *         Comparator<? super K> cpr = comparator;
         *         // 遍历红黑树,compare()比较，两对象是否相同
         *         // 若在红黑树中没有相同的key,就添加key;
         *         // 若在红黑树中有相同的key,将红黑树中的key对应的value值,替换成添加的key对应的value值。
         *         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;
         *             // 遍历红黑树,根据自定义对象的compareTo()比较，两对象是否相同
         *             // 若在红黑树中没有相同的key,就添加key;
         *             // 若在红黑树中有相同的key,将红黑树中的key对应的value值,替换成添加的key对应的value值。
         *             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);
         *         }
         *         Entry<K,V> e = new Entry<>(key, value, parent);
         *         if (cmp < 0)
         *             parent.left = e;
         *         else
         *             parent.right = e;
         *         fixAfterInsertion(e);
         *         size++;
         *         modCount++;
         *         return null;
         *     }
         *
         * 3) final int compare(Object k1, Object k2) {
         *         return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
         *             : comparator.compare((K)k1, (K)k2);
         *     }
         *    $ 比较k1和k2，① 用TreeMap的comparator比较器比较，② 用传入对象的compareTo()方法进行比较。
         */
    }
}

// 实现Compare接口的compareTo()方法
class A implements Comparable{
    private int num;

    public A(int num) {
        this.num = num;
    }

    @Override
    public int compareTo(Object o) {
        return this.num - ((A) o).num;
    }
}