您的位置: 首页  >  文章  >  java_集合体系之Map框架相关抽象类接口详解、源码

java_集合体系之Map框架相关抽象类接口详解、源码

分类: 文章 • 2023-11-26 18:10:46

  摘要：Set的实现是基于Map的、所以先搞懂Map、才能去理解Set、否则的话、直接去弄Set会觉得云里雾里、最后发现是浪费时间。这一节介绍关于Map的相关接口、抽象类的功能。


一：Map总体框架图

 java_集合体系之Map框架相关抽象类接口详解、源码

简单说明：

        1、上图中虚线且无依赖字样、说明是直接实现的接口

        2、虚线但是有依赖字样、说明此类依赖与接口、但不是直接实现接口

        3、实线是继承关系、类继承类、接口继承接口

        下面的介绍虽然这些都是关于抽象类、接口的定义、但是还是觉得从源码的方向介绍更能直观的说明问题、也更能加深对体系的理解、当然API同样不再给出、会在介绍其具体子类的时候将接口中的API和子类自己新增的API分离开来罗列。


二：Map<K, V>


        1、接口简介：

                a）以键值对的形式存储数据、每个键唯一对应一个值、键不允许重复、至于键是否允许为null、视子类而定。

                b）其中存放元素是否有序、视子类而定、如HashMap无序、Hashtable有序、排序规则可选按自然排序或者指定排序方式。

                c）允许以三种形式获取、迭代Map中的元素、获取键集、获取值集、获取键值实体。

                d）子类必须提供两个构造方法、一个是空构造方法、一个是含有指定传入的Map结构中的所有键值对的构造方法（此构造方法是将指定传入的Map智中的键值对全部复制为自己的键值对）。


        2、源码分析：


[java] view plain copy
 java_集合体系之Map框架相关抽象类接口详解、源码java_集合体系之Map框架相关抽象类接口详解、源码
  1. package com.chy.collection.core;  
  2.   
  3. public interface Map<K,V> {  
  4.     // Query Operations  
  5.   
  6.     /** 返回所有的映射的个数*/  
  7.     int size();  
  8.   
  9.     /** 是否含有映射*/  
  10.     boolean isEmpty();  
  11.   
  12.     /** 是否包含值为key的key*/  
  13.     boolean containsKey(Object key);  
  14.   
  15.     /** 是否包含值为value的value*/  
  16.     boolean containsValue(Object value);  
  17.   
  18.     /** 根据指定的key获取value*/  
  19.     V get(Object key);  
  20.   
  21.     // Modification Operations  
  22.   
  23.     /** 将一个键值对放入到Map中、返回以前与key关联的值*/  
  24.     V put(K key, V value);  
  25.   
  26.     /** 根据传入的key删除一个键值对、返回被删除的key映射的value*/  
  27.     V remove(Object key);  
  28.   
  29.   
  30.     // Bulk Operations  
  31.   
  32.     /** 将指定的Map中的所有的映射放入到当前Map中*/  
  33.     void putAll(Map<? extends K, ? extends V> m);  
  34.   
  35.     /** 删除当前Map中所有映射*/  
  36.     void clear();  
  37.   
  38.   
  39.     // Views  
  40.   
  41.     /** 获取由Map中所有key组成的Set*/  
  42.     Set<K> keySet();  
  43.   
  44.     /** 获取由Map中所有value组曾的Collection*/  
  45.     Collection<V> values();  
  46.   
  47.     /** 获取由Map中所有映射组成的实体类Map.Entry<K, V>组成的Set*/  
  48.     Set<Map.Entry<K, V>> entrySet();  
  49.   
  50.     /** 组成Map的键值对、仅在Iterator时使用*/  
  51.     interface Entry<K,V> {  
  52.         /** 获取当前映射的key*/  
  53.         K getKey();  
  54.   
  55.         /** 获取当前映射的value*/  
  56.         V getValue();  
  57.   
  58.         /** 设置当前映射的value*/  
  59.         V setValue(V value);  
  60.   
  61.         /** 判断当前Entry是否与传入的Object相等*/  
  62.         boolean equals(Object o);  
  63.   
  64.         /**获取当前Entry的哈希值*/  
  65.         int hashCode();  
  66.     }  
  67.   
  68.     // Comparison and hashing  
  69.   
  70.     /** 如果 m1.entrySet().equals(m2.entrySet())，则两个映射 m1 和 m2 表示相同的映射关系。*/  
  71.     boolean equals(Object o);  
  72.   
  73.     /** 返回此映射的哈希值*/  
  74.     int hashCode();  
  75. }  


        简单说明：Map的源码中的方法可以分成：查询、修改（包括添加、删除Map中的映射）、获取视图和一个仅在Iterator的时候使用的内部接口、接口中定义了操作迭代出的每个映射的方法——获取key、获取value、修改映射的value。源码==================

 

三：AbstractMap<K, V>


        1、抽象类简介：

        a）AbstractMap实现了Map接口、提供一些方法的实现、要求所有需要实现Map接口的实现类应该从AbstractMap中继承、可以大大简化编程的代码量。

        b）AbstractMap中的方法的简单实现都是围绕第一个获取视图的方法Set<Map.Entry<K, V>> entrySet();得到entrySet、进而获取entrySet的Iterator来操作的、

        c）获取视图的剩下两个方法方法是通过两个匿名类new AbstractSet<K>()、newAbstractCollection<V>来实现的。    

        d）还有两个内部类是维护键值对的。

        2、源码分析：


[java] view plain copy
 java_集合体系之Map框架相关抽象类接口详解、源码java_集合体系之Map框架相关抽象类接口详解、源码
  1. package com.chy.collection.core;  
  2. import java.util.Iterator;  
  3. import java.util.Map.Entry;  
  4.   
  5. public abstract class AbstractMap<K,V> implements Map<K,V> {  
  6.     /** 默认的构造方法、供子类调用*/  
  7.     protected AbstractMap() {}  
  8.   
  9.     // Query Operations  
  10.   
  11.     /** 返回当前Map映射个数*/  
  12.     public int size() {  
  13.         return entrySet().size();  
  14.     }  
  15.   
  16.     /** 当前映射是否为空*/  
  17.     public boolean isEmpty() {  
  18.         return size() == 0;  
  19.     }  
  20.   
  21.     /** 判断当前Map中是否有值为value的映射*/  
  22.     public boolean containsValue(Object value) {  
  23.         Iterator<Entry<K,V>> i = entrySet().iterator();  
  24.         if (value==null) {  
  25.             while (i.hasNext()) {  
  26.             Entry<K,V> e = i.next();  
  27.             if (e.getValue()==null)  
  28.                 return true;  
  29.             }  
  30.         } else {  
  31.             while (i.hasNext()) {  
  32.             Entry<K,V> e = i.next();  
  33.             if (value.equals(e.getValue()))  
  34.                 return true;  
  35.             }  
  36.         }  
  37.         return false;  
  38.     }  
  39.   
  40.     /** 判断当前Map中是否有键为key的映射*/  
  41.     public boolean containsKey(Object key) {  
  42.         Iterator<Map.Entry<K,V>> i = entrySet().iterator();  
  43.         if (key==null) {  
  44.             while (i.hasNext()) {  
  45.             Entry<K,V> e = i.next();  
  46.             if (e.getKey()==null)  
  47.                 return true;  
  48.             }  
  49.         } else {  
  50.             while (i.hasNext()) {  
  51.             Entry<K,V> e = i.next();  
  52.             if (key.equals(e.getKey()))  
  53.                 return true;  
  54.             }  
  55.         }  
  56.         return false;  
  57.     }  
  58.   
  59.     /** 获取键为key的值*/  
  60.     public V get(Object key) {  
  61.         Iterator<Entry<K,V>> i = entrySet().iterator();  
  62.         if (key==null) {  
  63.             while (i.hasNext()) {  
  64.             Entry<K,V> e = i.next();  
  65.             if (e.getKey()==null)  
  66.                 return e.getValue();  
  67.             }  
  68.         } else {  
  69.             while (i.hasNext()) {  
  70.             Entry<K,V> e = i.next();  
  71.             if (key.equals(e.getKey()))  
  72.                 return e.getValue();  
  73.             }  
  74.         }  
  75.         return null;  
  76.     }  
  77.   
  78.   
  79.     // Modification Operations  
  80.   
  81.     /** 将一个映射放入到Map中、要求子类要有自己的实现*/  
  82.     public V put(K key, V value) {  
  83.         throw new UnsupportedOperationException();  
  84.     }  
  85.   
  86.     /** 删除键为key的映射*/  
  87.     public V remove(Object key) {  
  88.         Iterator<Entry<K,V>> i = entrySet().iterator();  
  89.         Entry<K,V> correctEntry = null;  
  90.         if (key==null) {  
  91.             while (correctEntry==null && i.hasNext()) {  
  92.             Entry<K,V> e = i.next();  
  93.             if (e.getKey()==null)  
  94.                 correctEntry = e;  
  95.             }  
  96.         } else {  
  97.             while (correctEntry==null && i.hasNext()) {  
  98.             Entry<K,V> e = i.next();  
  99.             if (key.equals(e.getKey()))  
  100.                 correctEntry = e;  
  101.             }  
  102.         }  
  103.       
  104.         V oldValue = null;  
  105.         if (correctEntry !=null) {  
  106.             oldValue = correctEntry.getValue();  
  107.             i.remove();  
  108.         }  
  109.         return oldValue;  
  110.     }  
  111.   
  112.   
  113.     // Bulk Operations  
  114.   
  115.     /** 将指定Map中所有键值对都放入到当前Map中*/  
  116.     public void putAll(Map<? extends K, ? extends V> m) {  
  117.         for (Map.Entry<? extends K, ? extends V> e : m.entrySet())  
  118.             put(e.getKey(), e.getValue());  
  119.     }  
  120.   
  121.     /** 清空当前Map*/  
  122.     public void clear() {  
  123.         entrySet().clear();  
  124.     }  
  125.   
  126.   
  127.     // Views  
  128.   
  129.     transient volatile Set<K>        keySet = null;  
  130.     transient volatile Collection<V> values = null;  
  131.   
  132.     /** 获取有当前Map中所有key组成的Set*/  
  133.     public Set<K> keySet() {  
  134.         if (keySet == null) {  
  135.             //通过匿名类的方式获取keySet实体类  
  136.             keySet = new AbstractSet<K>() {  
  137.                 //实现获取Iterator的方法、并实现Iterator内部方法  
  138.                 public Iterator<K> iterator() {  
  139.                     return new Iterator<K>() {  
  140.                         private Iterator<Entry<K,V>> i = entrySet().iterator();  
  141.               
  142.                         public boolean hasNext() {  
  143.                             return i.hasNext();  
  144.                         }  
  145.               
  146.                         public K next() {  
  147.                             return i.next().getKey();  
  148.                         }  
  149.               
  150.                         public void remove() {  
  151.                             i.remove();  
  152.                         }  
  153.                     };  
  154.                 }  
  155.                   
  156.                 public int size() {  
  157.                     return AbstractMap.this.size();  
  158.                 }  
  159.           
  160.                 public boolean contains(Object k) {  
  161.                     return AbstractMap.this.containsKey(k);  
  162.                 }  
  163.             };  
  164.         }  
  165.         return keySet;  
  166.     }  
  167.   
  168.     /** 获取当前Map所有value组成的集合*/  
  169.     public Collection<V> values() {  
  170.         if (values == null) {  
  171.             //通过匿名类的方式获取Collection实体类  
  172.             values = new AbstractCollection<V>() {  
  173.                 //实现获取Iterator的方法、并实现Iterator内部方法  
  174.                 public Iterator<V> iterator() {  
  175.                     return new Iterator<V>() {  
  176.                         private Iterator<Entry<K,V>> i = entrySet().iterator();  
  177.               
  178.                         public boolean hasNext() {  
  179.                             return i.hasNext();  
  180.                         }  
  181.               
  182.                         public V next() {  
  183.                             return i.next().getValue();  
  184.                         }  
  185.               
  186.                         public void remove() {  
  187.                             i.remove();  
  188.                         }  
  189.                     };  
  190.                }  
  191.           
  192.                 public int size() {  
  193.                     return AbstractMap.this.size();  
  194.                 }  
  195.           
  196.                 public boolean contains(Object v) {  
  197.                     return AbstractMap.this.containsValue(v);  
  198.                 }  
  199.             };  
  200.         }  
  201.         return values;  
  202.     }  
  203.   
  204.     /** 获取由当前Map中所有映射组成的Set*/  
  205.     public abstract Set<Entry<K,V>> entrySet();  
  206.   
  207.   
  208.     // Comparison and hashing  
  209.   
  210.     public boolean equals(Object o) {  
  211.         //如果是他本身、返回true  
  212.         if (o == this)  
  213.             return true;  
  214.           
  215.         //如果传入的不是Map、返回false  
  216.         if (!(o instanceof Map))  
  217.             return false;  
  218.         Map<K,V> m = (Map<K,V>) o;  
  219.         //优化操作、如果传入的Map的size与当前被比较的Map的size不同、那么就可确定这两个Map不相等  
  220.         if (m.size() != size())  
  221.             return false;  
  222.           
  223.         //比较两个Map中的所有value是否相等、相等则返回true、不相等则返回false  
  224.         try {  
  225.             Iterator<Entry<K,V>> i = entrySet().iterator();  
  226.             while (i.hasNext()) {  
  227.                 Entry<K,V> e = i.next();  
  228.                 K key = e.getKey();  
  229.                 V value = e.getValue();  
  230.                 if (value == null) {  
  231.                     if (!(m.get(key)==null && m.containsKey(key)))  
  232.                         return false;  
  233.                 } else {  
  234.                     if (!value.equals(m.get(key)))  
  235.                         return false;  
  236.                 }  
  237.             }  
  238.         } catch (ClassCastException unused) {  
  239.             return false;  
  240.         } catch (NullPointerException unused) {  
  241.             return false;  
  242.         }  
  243.         return true;  
  244.     }  
  245.   
  246.     /**  返回此映射的哈希码值。*/  
  247.     public int hashCode() {  
  248.         int h = 0;  
  249.         Iterator<Entry<K,V>> i = entrySet().iterator();  
  250.         while (i.hasNext())  
  251.             h += i.next().hashCode();  
  252.         return h;  
  253.     }  
  254.   
  255.     /** 返回此映射的字符串表示形式。*/  
  256.     public String toString() {  
  257.         Iterator<Entry<K,V>> i = entrySet().iterator();  
  258.         if (! i.hasNext())  
  259.             return "{}";  
  260.       
  261.         StringBuilder sb = new StringBuilder();  
  262.         sb.append('{');  
  263.         for (;;) {  
  264.             Entry<K,V> e = i.next();  
  265.             K key = e.getKey();  
  266.             V value = e.getValue();  
  267.             sb.append(key   == this ? "(this Map)" : key);  
  268.             sb.append('=');  
  269.             sb.append(value == this ? "(this Map)" : value);  
  270.             if (! i.hasNext())  
  271.             return sb.append('}').toString();  
  272.             sb.append(", ");  
  273.         }  
  274.     }  
  275.   
  276.     /** 返回当前Map的克隆的值*/  
  277.     protected Object clone() throws CloneNotSupportedException {  
  278.         AbstractMap<K,V> result = (AbstractMap<K,V>)super.clone();  
  279.         result.keySet = null;  
  280.         result.values = null;  
  281.         return result;  
  282.     }  
  283.   
  284.     /** 比较两个对象是否相等*/  
  285.     private static boolean eq(Object o1, Object o2) {  
  286.         return o1 == null ? o2 == null : o1.equals(o2);  
  287.     }  
  288.   
  289.     // Implementation Note: SimpleEntry and SimpleImmutableEntry  
  290.     // are distinct unrelated classes, even though they share  
  291.     // some code. Since you can't add or subtract final-ness  
  292.     // of a field in a subclass, they can't share representations,  
  293.     // and the amount of duplicated code is too small to warrant  
  294.     // exposing a common abstract class.  
  295.   
  296.   
  297.     /** 维护键和值的 Entry、此类支持setValue*/  
  298.     public static class SimpleEntry<K,V> implements Entry<K,V>, java.io.Serializable {  
  299.         private static final long serialVersionUID = -8499721149061103585L;  
  300.       
  301.         private final K key;  
  302.         private V value;  
  303.       
  304.         public SimpleEntry(K key, V value) {  
  305.             this.key   = key;  
  306.                 this.value = value;  
  307.         }  
  308.         public SimpleEntry(Entry<? extends K, ? extends V> entry) {  
  309.             this.key   = entry.getKey();  
  310.                 this.value = entry.getValue();  
  311.         }  
  312.       
  313.         public K getKey() {  
  314.             return key;  
  315.         }  
  316.       
  317.         public V getValue() {  
  318.             return value;  
  319.         }  
  320.       
  321.         public V setValue(V value) {  
  322.             V oldValue = this.value;  
  323.             this.value = value;  
  324.             return oldValue;  
  325.         }  
  326.       
  327.         public boolean equals(Object o) {  
  328.             if (!(o instanceof Map.Entry))  
  329.             return false;  
  330.             Map.Entry e = (Map.Entry)o;  
  331.             return eq(key, e.getKey()) && eq(value, e.getValue());  
  332.         }  
  333.       
  334.         public int hashCode() {  
  335.             return (key   == null ? 0 :   key.hashCode()) ^  
  336.                (value == null ? 0 : value.hashCode());  
  337.         }  
  338.       
  339.         public String toString() {  
  340.             return key + "=" + value;  
  341.         }  
  342.     }  
  343.   
  344.     /**维护不可变的键和值的 Entry、此类不支持 setValue 方法。一般用在多线程环境中*/  
  345.     public static class SimpleImmutableEntry<K,V> implements Entry<K,V>, java.io.Serializable {  
  346.         private static final long serialVersionUID = 7138329143949025153L;  
  347.       
  348.         private final K key;  
  349.         private final V value;  
  350.         public SimpleImmutableEntry(K key, V value) {  
  351.             this.key   = key;  
  352.                 this.value = value;  
  353.         }  
  354.         public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {  
  355.             this.key   = entry.getKey();  
  356.                 this.value = entry.getValue();  
  357.         }  
  358.   
  359.         public K getKey() {  
  360.             return key;  
  361.         }  
  362.         public V getValue() {  
  363.             return value;  
  364.         }  
  365.         public V setValue(V value) {  
  366.             throw new UnsupportedOperationException();  
  367.         }  
  368.   
  369.         public boolean equals(Object o) {  
  370.             if (!(o instanceof Map.Entry))  
  371.             return false;  
  372.             Map.Entry e = (Map.Entry)o;  
  373.             return eq(key, e.getKey()) && eq(value, e.getValue());  
  374.         }  
  375.   
  376.         public int hashCode() {  
  377.             return (key   == null ? 0 :   key.hashCode()) ^  
  378.                (value == null ? 0 : value.hashCode());  
  379.         }  
  380.   
  381.         public String toString() {  
  382.             return key + "=" + value;  
  383.         }  
  384.     }  
  385. }  


四：SortedMap<K, V>


        1、接口简介：

        a）进一步提供关于键的总体排序的Map。该映射是根据其键的自然顺序进行排序的，或者根据通常在创建有序映射时提供的Comparator 进行排序

 

        b）插入所有有序映射的键都要实现Comparable接口、所有这些键都是可以比较的。

 

        c）内部方法都是围绕key的排序定义的、概括为： （1）获取大于、小于指定键的子Map、       （2）获取key所在指定范围的子集Map。获取第一个、最后一个键、    （3）获取三种视图的方法。（4）获取当前集合的排序比较器。

        2、源码分析：

      

[java] view plain copy
 java_集合体系之Map框架相关抽象类接口详解、源码java_集合体系之Map框架相关抽象类接口详解、源码
  1. package com.chy.collection.core;  
  2.   
  3. import java.util.Comparator;  
  4.   
  5.   
  6. public interface SortedMap<K,V> extends Map<K,V> {  
  7.       
  8.     /** 返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。*/  
  9.     Comparator<? super K> comparator();  
  10.   
  11.     /** 返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。*/  
  12.     SortedMap<K,V> subMap(K fromKey, K toKey);  
  13.   
  14.     /** 返回此映射的部分视图，其键值严格小于 toKey。*/  
  15.     SortedMap<K,V> headMap(K toKey);  
  16.   
  17.     /** 返回此映射的部分视图，其键大于等于 fromKey。*/  
  18.     SortedMap<K,V> tailMap(K fromKey);  
  19.   
  20.     /**  返回此映射中当前第一个（最低）键。*/  
  21.     K firstKey();  
  22.   
  23.     /**  返回此映射中当前第一个（最低）键。*/  
  24.     K lastKey();  
  25.   
  26.     /** 返回在此映射中所包含键的 Set 视图。*/  
  27.     Set<K> keySet();  
  28.   
  29.     /**  返回在此映射中所包含值的 Collection 视图。*/  
  30.     Collection<V> values();  
  31.   
  32.     /** 返回在此映射中包含的映射关系的 Set 视图。*/  
  33.     Set<Map.Entry<K, V>> entrySet();  
  34. }  


五：NavigableMap<K, V>


        1、接口简介：

                a）是对SortedMap接口的扩展、

                b）方法 lowerEntry、floorEntry、ceilingEntry 和higherEntry 分别返回与小于、小于等于、大于等于、大于给定键的键关联的 Map.Entry 对象。

                c）方法 lowerKey、floorKey、ceilingKey 和higherKey 只返回关联的键。

                d）可以按照键的升序或降序访问和遍历 NavigableMap

                e）subMap、headMap 和tailMap 方法与名称相似的 SortedMap 方法的不同之处在于：可以接受用于描述是否包括（或不包括）下边界和上边界的附加参数

                f）firstEntry、pollFirstEntry、lastEntry 和pollLastEntry 方法，它们返回和/或移除最小和最大的映射关系（如果存在），否则返回 null。

        2、源码分析：


[java] view plain copy
 java_集合体系之Map框架相关抽象类接口详解、源码java_集合体系之Map框架相关抽象类接口详解、源码
  1. package com.chy.collection.core;  
  2.   
  3. import java.util.NavigableSet;  
  4.   
  5. public interface NavigableMap<K,V> extends SortedMap<K,V> {  
  6.       
  7.     /** 返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。*/  
  8.     Map.Entry<K,V> lowerEntry(K key);  
  9.   
  10.     /**  返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。*/  
  11.     K lowerKey(K key);  
  12.   
  13.     /**  返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。*/  
  14.     Map.Entry<K,V> floorEntry(K key);  
  15.   
  16.     /** 返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。*/  
  17.     K floorKey(K key);  
  18.   
  19.     /**  返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。*/  
  20.     Map.Entry<K,V> ceilingEntry(K key);  
  21.   
  22.     /** 返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。*/  
  23.     K ceilingKey(K key);  
  24.   
  25.     /** 返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。*/  
  26.     Map.Entry<K,V> higherEntry(K key);  
  27.   
  28.     /**  返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。*/  
  29.     K higherKey(K key);  
  30.   
  31.     /** 返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。*/  
  32.     Map.Entry<K,V> firstEntry();  
  33.   
  34.     /** 返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。*/  
  35.     Map.Entry<K,V> lastEntry();  
  36.   
  37.     /** 移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。*/  
  38.     Map.Entry<K,V> pollFirstEntry();  
  39.   
  40.     /**  移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。*/  
  41.     Map.Entry<K,V> pollLastEntry();  
  42.   
  43.     /** 返回此映射中所包含映射关系的逆序视图。*/  
  44.     NavigableMap<K,V> descendingMap();  
  45.   
  46.     /**  返回此映射中所包含键的 NavigableSet 视图。*/  
  47.     NavigableSet<K> navigableKeySet();  
  48.   
  49.     /** 返回此映射中所包含键的逆序 NavigableSet 视图。*/  
  50.     NavigableSet<K> descendingKeySet();  
  51.   
  52.     /**  返回此映射的部分视图，其键的范围从 fromKey 到 toKey。*/  
  53.     NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,  
  54.                              K toKey,   boolean toInclusive);  
  55.   
  56.     /** 返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。*/  
  57.     NavigableMap<K,V> headMap(K toKey, boolean inclusive);  
  58.   
  59.     /**  返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。*/  
  60.     NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);  
  61.   
  62.     /** 返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。*/  
  63.     SortedMap<K,V> subMap(K fromKey, K toKey);  
  64.   
  65.     /** 返回此映射的部分视图，其键值严格小于 toKey。*/  
  66.     SortedMap<K,V> headMap(K toKey);  
  67.   
  68.     /** 返回此映射的部分视图，其键大于等于 fromKey。*/  
  69.     SortedMap<K,V> tailMap(K fromKey);  
  70. }

相关推荐