TreeMap和TreeSet特有的API

 TreeMap

因为TreeMap能比较大小，新增的方法一般和大小比较有关

Map.Entry<K,V> ceilingEntry(K key)：返回大于等于并最接近key的一个键值对，不存在返回 null

K ceilingKey(K key)：返回大于等于并最接近key的键值，不存在返回 null，相当于ceilingEntry的结果调用getKey()

Comparator<? super K> comparator(): 返回比较器，如果map用自然顺序比较返回null


NavigableSet<K> descendingKeySet()：视图方法, 获得逆序key集合

NavigableMap<K,V> descendingMap(): 视图方法, 获得逆序map
TreeMap<Integer,String> map = new TreeMap<>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        System.out.println(map.descendingMap());
//结果：{3=c, 2=b, 1=a}


              Map.Entry<K,V> firstEntry(): 返回第一个键值对
        System.out.println(map.firstEntry());//1=a


        K firstKey()
        返回此映射中当前第一个（最低）键。


        Map.Entry<K,V> floorEntry(K key)： 返回一个键值对， 小于等于给定的key
        返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。

        System.out.println(map.floorEntry(4));


        K floorKey(K key)
        返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。
        System.out.println(map.floorKey(100));




        SortedMap<K,V> headMap(K toKey): 视图方法, 返回map, 严格小于给定key
        返回此映射的部分视图，其键值严格小于 toKey。
        System.out.println(map.headMap(5));


         inclusive: 真 --> 小于等于
                     假 --> 严格小于
        NavigableMap<K,V> headMap(K toKey, boolean inclusive): 视图方法, 返回map, 小于给定key
        返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。
        System.out.println(map.headMap(5, true));


        Map.Entry<K,V> higherEntry(K key): 严格大于给定key的key-value数据
        返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。
         System.out.println(map.higherEntry(4)); 5 = 5


        K higherKey(K key)
        返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
        System.out.println(map.higherKey(4)); // 5

        Set<K> keySet(): 键集
        返回此映射包含的键的 Set 视图。
        System.out.println(map.keySet());


        Map.Entry<K,V> lastEntry()
        返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
         System.out.println(map.lastEntry());


        K lastKey()
        返回映射中当前最后一个（最高）键。


        Map.Entry<K,V> lowerEntry(K key)
        返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。
         System.out.println(map.lowerEntry(4));


        K lowerKey(K key)
        返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。



        NavigableSet<K> navigableKeySet()
        返回此映射中所包含键的 Set 视图。
         System.out.println(map.navigableKeySet());


        Map.Entry<K,V> pollFirstEntry()
        移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null
        。
        map.pollLastEntry();
        System.out.println(map);

        Map.Entry<K,V> pollLastEntry()
        移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。


        V put(K key, V value)
        将指定值与此映射中的指定键进行关联。
        void putAll(Map<? extends K,? extends V> map)
        将指定映射中的所有映射关系复制到此映射中。
        V remove(Object key)
        如果此 TreeMap 中存在该键的映射关系，则将其删除。
        int size()
        返回此映射中的键-值映射关系数。


        SortedMap<K,V> subMap(K fromKey, K toKey)
        返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。
        SortedMap<Integer, Integer> integerIntegerSortedMap = map.subMap(1, 5);
        System.out.println(integerIntegerSortedMap);

        NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
        返回此映射的部分视图，其键的范围从 fromKey 到 toKey。
        SortedMap<Integer, Integer> integerIntegerSortedMap = map.subMap(1, false, 5, true);
        System.out.println(integerIntegerSortedMap);




        SortedMap<K,V> tailMap(K fromKey): map. 大于等于key
        返回此映射的部分视图，其键大于等于 fromKey。
        System.out.println(map.tailMap(3, false));

        NavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
        返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。
        Collection<V> values(): 值集
        返回此映射包含的值的 Collection 视图。

TreeSet

         TreeSet<Integer> set = new TreeSet<>();
        set.add(1);
        set.add(3);
        set.add(5);
        set.add(6);
        set.add(8);
        

E ceiling(E e)
        返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
        Integer ceiling = set.ceiling(4);
        System.out.println(ceiling);// 5



        Iterator<E> descendingIterator()
        返回在此 set 元素上按降序进行迭代的迭代器。
        Iterator<Integer> integerIterator = set.descendingIterator();
        while (integerIterator.hasNext()){
            System.out.println(integerIterator.next());
        }


        NavigableSet<E> descendingSet()
        返回此 set 中所包含元素的逆序视图。
        NavigableSet<Integer> integers = set.descendingSet();
        System.out.println(integers);


        E first()
        返回此 set 中当前第一个（最低）元素。
        System.out.println(set.first());


        E floor(E e)
        返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
        System.out.println(set.floor(4));


        SortedSet<E> headSet(E toElement)
        返回此 set 的部分视图，其元素严格小于 toElement。
        SortedSet<Integer> integers = set.headSet(7);
        System.out.println(integers);// [1, 3, 5, 6]


        NavigableSet<E> headSet(E toElement, boolean inclusive)
        返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。
        SortedSet<Integer> integers = set.headSet(8, true);
        System.out.println(integers);// [1, 3, 5, 6, 8]


        E higher(E e)
        返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
        System.out.println(set.higher(5));


        boolean isEmpty()
        如果此 set 不包含任何元素，则返回 true。
        Iterator<E> iterator()
        返回在此 set 中的元素上按升序进行迭代的迭代器。


        E last()
        返回此 set 中当前最后一个（最高）元素。
        System.out.println(set.last());//8


        E lower(E e)
        返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
        System.out.println(set.lower(3));// 1


        E pollFirst()
        获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
        System.out.println(set.pollFirst());
        System.out.println(set);

        E pollLast()
        获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
        System.out.println(set.pollLast());
        System.out.println(set);


        boolean remove(Object o)
        将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
        int size()
        返回 set 中的元素数（set 的容量）。


        NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
        返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
        SortedSet<E> subSet(E fromElement, E toElement)
        返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。

        SortedSet<Integer> integers = set.subSet(1,false, 5,true);
        System.out.println(integers);// 3 5


        SortedSet<E> tailSet(E fromElement)
        返回此 set 的部分视图，其元素大于等于 fromElement。
        NavigableSet<E> tailSet(E fromElement, boolean inclusive)
        返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。
        SortedSet<Integer> integers = set.tailSet(5, false);
        System.out.println(integers);// 6 8