Java 中的Set之TreeSet再认知

目录

代码

方法

 LearnTreeMap.java

---

Java代码写了不少，但是就是碎片化的，现在系统的整理一下；

代码

方法

从类 java.util.AbstractMap 继承的嵌套类/接口
     AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V> 

构造方法摘要
     TreeMap()
               使用键的自然顺序构造一个新的、空的树映射。
     TreeMap(Comparator<? super K> comparator)
               构造一个新的、空的树映射，该映射根据给定比较器进行排序。
     TreeMap(Map<? extends K,? extends V> m)
               构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序 进行排序。
     TreeMap(SortedMap<K,? extends V> m)
               构造一个与指定有序映射具有相同映射关系和相同排序顺序的新的树映射。 

方法摘要
      Map.Entry<K,V>     ceilingEntry(K key)
               返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。
      K   ceilingKey(K key)
               返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
      void     clear()
               从此映射中移除所有映射关系。
      Object   clone()
               返回此 TreeMap 实例的浅表副本。
      Comparator<? super K>   comparator()
               返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
      boolean  containsKey(Object key)
               如果此映射包含指定键的映射关系，则返回 true。
      boolean  containsValue(Object value)
               如果此映射为指定值映射一个或多个键，则返回 true。
      NavigableSet<K>    descendingKeySet()
               返回此映射中所包含键的逆序 NavigableSet 视图。
      NavigableMap<K,V>  descendingMap()
               返回此映射中所包含映射关系的逆序视图。
      Set<Map.Entry<K,V>>     entrySet()
               返回此映射中包含的映射关系的 Set 视图。
      Map.Entry<K,V>     firstEntry()
               返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
      K   firstKey()
               返回此映射中当前第一个（最低）键。
      Map.Entry<K,V>     floorEntry(K key)
               返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。
      K   floorKey(K key)
               返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。
      V   get(Object key)
               返回指定键所映射的值，如果对于该键而言，此映射不包含任何映射关系，则返回 null。
      SortedMap<K,V>     headMap(K toKey)
               返回此映射的部分视图，其键值严格小于 toKey。
      NavigableMap<K,V>  headMap(K toKey, boolean inclusive)
               返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。
      Map.Entry<K,V>     higherEntry(K key)
               返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。
      K   higherKey(K key)
               返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
      Set<K>   keySet()
               返回此映射包含的键的 Set 视图。
      Map.Entry<K,V>     lastEntry()
               返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
      K   lastKey()
               返回映射中当前最后一个（最高）键。
      Map.Entry<K,V>     lowerEntry(K key)
               返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。
      K   lowerKey(K key)
               返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。
      NavigableSet<K>    navigableKeySet()
               返回此映射中所包含键的 NavigableSet 视图。
      Map.Entry<K,V>     pollFirstEntry()
               移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
      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()
               返回此映射中的键-值映射关系数。
      NavigableMap<K,V>  subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
               返回此映射的部分视图，其键的范围从 fromKey 到 toKey。
      SortedMap<K,V>     subMap(K fromKey, K toKey)
               返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。
      SortedMap<K,V>     tailMap(K fromKey)
               返回此映射的部分视图，其键大于等于 fromKey。
      NavigableMap<K,V>  tailMap(K fromKey, boolean inclusive)
               返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。
      Collection<V> values()
               返回此映射包含的值的 Collection 视图。 

从类 java.util.AbstractMap 继承的方法
     equals, hashCode, isEmpty, toString 
从类 java.lang.Object 继承的方法
     finalize, getClass, notify, notifyAll, wait, wait, wait 
从接口 java.util.Map 继承的方法
     equals, hashCode, isEmpty

LearnTreeMap.java

package javacollection.set;


import org.omg.CORBA.OBJECT_NOT_EXIST;

import java.util.*;

public class LearnTreeMap {
    public static void main(String[] args){
        String[] softWare = {"Hadoop","Spark","Hive","Hbase"};
        Set treeSet = new TreeSet();

        // 将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
        treeSet.add("1");
        treeSet.add("2");
        treeSet.add("100");
        treeSet.add("30");

        treeSet.add("Hello");
        treeSet.add("Java");

        //将指定 collection 中的所有元素添加到此 set 中。
        treeSet.addAll(Arrays.asList(softWare));

        System.out.println("treeSet: "+treeSet.toString());


        //返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
        Comparable comparable = (Comparable) ((TreeSet) treeSet).comparator();
        System.out.println("comparable: "+ comparable);


        //如果此 set 包含指定的元素，则返回 true。
        boolean iscontains = treeSet.contains("Hello");
        System.out.println("treeSet contains Hello: "+ iscontains);

        // 返回在此 set 元素上按降序进行迭代的迭代器。
        Iterator descIterator = ((TreeSet) treeSet).descendingIterator();
        String string = "";
        while (descIterator.hasNext()){
            String next = String.valueOf(descIterator.next());
            string = string+" "+next;

        }
        System.out.println("descIterator: "+ string);


        //返回此 set 中所包含元素的逆序视图。
        NavigableSet set = ((TreeSet) treeSet).descendingSet();
        System.out.println("set: "+ set.toString());

        // 返回此 set 中当前第一个（最低）元素。
        Object first = ((TreeSet) treeSet).first();
        System.out.println("first: "+ first);

        //返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null
        Object floor = ((TreeSet) treeSet).floor("H");
        System.out.println("floor: "+ floor);

        //返回此 set 的部分视图，其元素严格小于 toElement。
        SortedSet sortedSet = ((TreeSet) treeSet).headSet("S");
        System.out.println("sortedSet: "+ sortedSet.toString() );

        //返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。
        NavigableSet navigableSet = ((TreeSet) treeSet).headSet("Java", true);
        System.out.println("navigableSet: "+ navigableSet.toString());
        //返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。
        NavigableSet navigableSetFlase = ((TreeSet) treeSet).headSet("Java", false);
        System.out.println("navigableSet: "+ navigableSetFlase.toString());

        //返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
        Object higher = ((TreeSet) treeSet).higher("Hive");
        System.out.println("higher: "+higher);

        //  如果此 set 不包含任何元素，则返回 true。
        boolean isEmpty = treeSet.isEmpty();
        System.out.println("is empty: "+ isEmpty);

        //返回在此 set 中的元素上按升序进行迭代的迭代器。
        Iterator iterator = treeSet.iterator();
        System.out.print("iterator: ");
        while (iterator.hasNext()){
            System.out.print(iterator.next()+" ");
        }
        System.out.println();

        // 返回此 set 中当前最后一个（最高）元素。
        Object last = ((TreeSet) treeSet).last();
        System.out.println("last: "+last);

        // 返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
        Object lower = ((TreeSet) treeSet).lower("Java");
        System.out.println("lower: "+lower);

        // 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
        Object pollFirst = ((TreeSet) treeSet).pollFirst();
        System.out.println("pollFirst: "+ pollFirst);

        System.out.println("treeSet: "+ treeSet.toString());

        // 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
        Object pollLast = ((TreeSet) treeSet).pollLast();
        System.out.println("pollLast: "+ pollLast);

        System.out.println("treeSet: "+ treeSet.toString());


        // 将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
        boolean removeHello = treeSet.remove("Hello");
        System.out.println("removeHello: "+ removeHello);
        System.out.println("treeSet: "+ treeSet.toString());

        //返回 set 中的元素数（set 的容量）。
        int size = treeSet.size();
        System.out.println("size: "+size);

        //返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
        NavigableSet subSet = ((TreeSet) treeSet).subSet("2", true,"Hive", true);
        System.out.println("subSet: "+subSet.toString());

        //返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）
        SortedSet subSet1 = ((TreeSet) treeSet).subSet("2", "Hive");
        System.out.println("subSet1: "+ subSet1.toString());

        // 返回此 set 的部分视图，其元素大于等于 fromElement。
        SortedSet tailSet = ((TreeSet) treeSet).tailSet("2");
        System.out.println("tailSet: "+ tailSet.toString());

        //返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。
        NavigableSet tailSet1 = ((TreeSet) treeSet).tailSet("2",false);
        System.out.println("tailSet1: "+ tailSet1);

    }
}