类关系图

SortedMap - 图1

功能介绍

包路径：java.util

说明：SortedMap直接继承了Map接口，提供了若干个与排序相关的方法，如获取最大最小key值等

SortedMap典型实现子类常用的几个如NavigableMap接口、TreeMap类(实现NavigableMap)等。

源码解析

SortedMap

  1. /**
  2.  * 
  3.  * 直接继承Map接口，提供了若干个与排序相关的方法，使其能够进行排序
  4.  *
  5.  * @param <K> the type of keys maintained by this map
  6.  * @param <V> the type of mapped values
  7.  *
  8.  * @author  Josh Bloch
  9.  * @see Map
  10.  * @see TreeMap
  11.  * @see SortedSet
  12.  * @see Comparator
  13.  * @see Comparable
  14.  * @see Collection
  15.  * @see ClassCastException
  16.  * @since 1.2
  17.  */
  18. public interface SortedMap<K,V> extends Map<K,V> {
  19.     /**
  20.      * Returns the comparator used to order the keys in this map, or
  21.      * {@code null} if this map uses the {@linkplain Comparable
  22.      * natural ordering} of its keys.
  23.      * 
  24.      * 返回一个比较器，内部使用key的自然大小排序
  25.      *
  26.      * @return the comparator used to order the keys in this map,
  27.      *         or {@code null} if this map uses the natural ordering
  28.      *         of its keys
  29.      */
  30.     Comparator<? super K> comparator();
  32.     /**
  33.      * Returns a view of the portion of this map whose keys range from
  34.      * {@code fromKey}, inclusive, to {@code toKey}, exclusive.  (If
  35.      * {@code fromKey} and {@code toKey} are equal, the returned map
  36.      * is empty.)  The returned map is backed by this map, so changes
  37.      * in the returned map are reflected in this map, and vice-versa.
  38.      * The returned map supports all optional map operations that this
  39.      * map supports.
  40.      *
  41.      * 截取Map，返回从fromKey到toKey的映射子集合【左开右闭】
  42.      *
  43.      * @param fromKey low endpoint (inclusive) of the keys in the returned map
  44.      * @param toKey high endpoint (exclusive) of the keys in the returned map
  45.      * @return a view of the portion of this map whose keys range from
  46.      *         {@code fromKey}, inclusive, to {@code toKey}, exclusive
  47.      */
  48.     SortedMap<K,V> subMap(K fromKey, K toKey);
  50.     /**
  51.      * Returns a view of the portion of this map whose keys are
  52.      * strictly less than {@code toKey}.  The returned map is backed
  53.      * by this map, so changes in the returned map are reflected in
  54.      * this map, and vice-versa.  The returned map supports all
  55.      * optional map operations that this map supports.
  56.      *
  57.      * 返回key值小于toKey的Map映射
  58.      *
  59.      * @param toKey high endpoint (exclusive) of the keys in the returned map
  60.      * @return a view of the portion of this map whose keys are strictly
  61.      *         less than {@code toKey}
  62.      */
  63.     SortedMap<K,V> headMap(K toKey);
  65.     /**
  66.      * Returns a view of the portion of this map whose keys are
  67.      * greater than or equal to {@code fromKey}.  The returned map is
  68.      * backed by this map, so changes in the returned map are
  69.      * reflected in this map, and vice-versa.  The returned map
  70.      * supports all optional map operations that this map supports.
  71.      *
  72.      * 返回key值大于fromKey的Map映射
  73.      *
  74.      * @param fromKey low endpoint (inclusive) of the keys in the returned map
  75.      * @return a view of the portion of this map whose keys are greater
  76.      *         than or equal to {@code fromKey}
  77.      */
  78.     SortedMap<K,V> tailMap(K fromKey);
  80.     /**
  81.      * Returns the first (lowest) key currently in this map.
  82.      * 
  83.      * 返回最小key 
  84.      *
  85.      * @return the first (lowest) key currently in this map
  86.      * @throws NoSuchElementException if this map is empty
  87.      */
  88.     K firstKey();
  90.     /**
  91.      * Returns the last (highest) key currently in this map.
  92.      *
  93.      * 返回最大key
  94.      *
  95.      * @return the last (highest) key currently in this map
  96.      * @throws NoSuchElementException if this map is empty
  97.      */
  98.     K lastKey();
  100.     /**
  101.      *返回key的set集合
  102.      *
  103.      * @return a set view of the keys contained in this map, sorted in
  104.      *         ascending order
  105.      */
  106.     Set<K> keySet();
  108.     /**
  109.      * 返回value的Collection集合
  110.      *
  111.      * @return a collection view of the values contained in this map,
  112.      *         sorted in ascending key order
  113.      */
  114.     Collection<V> values();
  116.     /**
  117.      * 返回Entry映射集合
  118.      *
  119.      * @return a set view of the mappings contained in this map,
  120.      *         sorted in ascending key order
  121.      */
  122.     Set<Map.Entry<K, V>> entrySet();
  123. }

NavigableMap

SortedMap接口主要提供了获取最大值与最小值的方法，但对于一个已经排序的数据集，除了最大值与最小值之外，我们还需要些别的功能，更快的，比如获取比某个key值大或者小的值等

NavigableMap继承了SortedMap接口，主要扩展了一些便于匹配的导航方法，且主要是为了查找而不是遍历

  1. /**
  2.  * @author Doug Lea
  3.  * @author Josh Bloch
  4.  * @param <K> the type of keys maintained by this map
  5.  * @param <V> the type of mapped values
  6.  * @since 1.6
  7.  */
  8. public interface NavigableMap<K,V> extends SortedMap<K,V> {
  10.     /**
  11.      *  获取比传入key值小的最大映射
  12.      *
  13.      * @param key the key
  14.      * @return an entry with the greatest key less than {@code key},
  15.      *         or {@code null} if there is no such key
  16.      */
  17.     Map.Entry<K,V> lowerEntry(K key);
  19.     /**
  20.      * 获取比传入key值小的最大key
  21.      *
  22.      * @param key the key
  23.      * @return the greatest key less than {@code key},
  24.      *         or {@code null} if there is no such key
  25.      * 
  26.      */
  27.     K lowerKey(K key);
  29.     /**
  30.      * 返回键值小于等于传入key的最大映射
  31.      *
  32.      * @param key the key
  33.      * @return an entry with the greatest key less than or equal to
  34.      *         {@code key}, or {@code null} if there is no such key
  35.      * 
  36.      */
  37.     Map.Entry<K,V> floorEntry(K key);
  39.     /**
  40.      * 返回键值小于等于传入key的最大key值
  41.      *
  42.      * @param key the key
  43.      * @return the greatest key less than or equal to {@code key},
  44.      *         or {@code null} if there is no such key
  45.      * 
  46.      */
  47.     K floorKey(K key);
  49.     /**
  50.      * 返回大于等于传入key值的第一个映射
  51.      *
  52.      * @param key the key
  53.      * @return an entry with the least key greater than or equal to
  54.      *         {@code key}, or {@code null} if there is no such key
  55.      * 
  56.      */
  57.     Map.Entry<K,V> ceilingEntry(K key);
  59.     /**
  60.      * 返回大于等于传入key的第一个key值
  61.      *
  62.      * @param key the key
  63.      * @return the least key greater than or equal to {@code key},
  64.      *         or {@code null} if there is no such key
  65.      * 
  66.      */
  67.     K ceilingKey(K key);
  69.     /**
  70.      * 返回大于传入key的最小映射
  71.      *
  72.      * @param key the key
  73.      * @return an entry with the least key greater than {@code key},
  74.      *         or {@code null} if there is no such key
  75.      * 
  76.      */
  77.     Map.Entry<K,V> higherEntry(K key);
  79.     /**
  80.      * 返回大于传入key的最小key值
  81.      *
  82.      * @param key the key
  83.      * @return the least key greater than {@code key},
  84.      *         or {@code null} if there is no such key
  85.      *
  86.      */
  87.     K higherKey(K key);
  89.     /**
  90.      * 获取最小key映射
  91.      *
  92.      * @return an entry with the least key,
  93.      *         or {@code null} if this map is empty
  94.      */
  95.     Map.Entry<K,V> firstEntry();
  97.     /**
  98.      * 获取最大key映射
  99.      *
  100.      * @return an entry with the greatest key,
  101.      *         or {@code null} if this map is empty
  102.      */
  103.     Map.Entry<K,V> lastEntry();
  105.     /**
  106.      * 删除最小key映射
  107.      *
  108.      * @return the removed first entry of this map,
  109.      *         or {@code null} if this map is empty
  110.      */
  111.     Map.Entry<K,V> pollFirstEntry();
  113.     /**
  114.      * 删除最大key映射
  115.      *
  116.      * @return the removed last entry of this map,
  117.      *         or {@code null} if this map is empty
  118.      */
  119.     Map.Entry<K,V> pollLastEntry();
  121.     /**
  122.      * 返回倒序Map
  123.      *
  124.      * @return a reverse order view of this map
  125.      */
  126.     NavigableMap<K,V> descendingMap();
  128.     /**
  129.      * 返回一个key的NavigableSet集合，NavigableSet和NavigableMap类似
  130.      *
  131.      * @return a navigable set view of the keys in this map
  132.      */
  133.     NavigableSet<K> navigableKeySet();
  135.     /**
  136.      * 对上述集合倒序
  137.      *
  138.      * @return a reverse order navigable set view of the keys in this map
  139.      */
  140.     NavigableSet<K> descendingKeySet();
  142.     /**
  143.      * 截取Map，返回一个从 fromKey 至 toKey 的子Map，是否包含fromKey和toKey由fromInclusive和toInclusive决定
  144.      *
  145.      * @param fromKey low endpoint of the keys in the returned map
  146.      * @param fromInclusive {@code true} if the low endpoint
  147.      *        is to be included in the returned view
  148.      * @param toKey high endpoint of the keys in the returned map
  149.      * @param toInclusive {@code true} if the high endpoint
  150.      *        is to be included in the returned view
  151.      * @return a view of the portion of this map whose keys range from
  152.      *         {@code fromKey} to {@code toKey}
  153.      * 
  154.      */
  155.     NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
  156.                              K toKey,   boolean toInclusive);
  158.     /**
  159.      * 返回一个键值小于等于fromKey的子Map（inclusive决定是否包含有fromKey）
  160.      *
  161.      * @param toKey high endpoint of the keys in the returned map
  162.      * @param inclusive {@code true} if the high endpoint
  163.      *        is to be included in the returned view
  164.      * @return a view of the portion of this map whose keys are less than
  165.      *         (or equal to, if {@code inclusive} is true) {@code toKey}
  166.      * 
  167.      */
  168.     NavigableMap<K,V> headMap(K toKey, boolean inclusive);
  170.     /**
  171.      * 返回一个键值大于等于toKey的子Map（inclusive决定是否包含有toKey）
  172.      *
  173.      * <p>The returned map will throw an {@code IllegalArgumentException}
  174.      * on an attempt to insert a key outside its range.
  175.      *
  176.      * @param fromKey low endpoint of the keys in the returned map
  177.      * @param inclusive {@code true} if the low endpoint
  178.      *        is to be included in the returned view
  179.      * @return a view of the portion of this map whose keys are greater than
  180.      *         (or equal to, if {@code inclusive} is true) {@code fromKey}
  181.      * 
  182.      */
  183.     NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
  185.     /**
  186.      * 返回一个键值从fromKey到toKey的子Map（左开右闭）
  187.      *
  188.      * <p>Equivalent to {@code subMap(fromKey, true, toKey, false)}.
  189.      *
  190.      * @throws ClassCastException       {@inheritDoc}
  191.      * @throws NullPointerException     {@inheritDoc}
  192.      * @throws IllegalArgumentException {@inheritDoc}
  193.      */
  194.     SortedMap<K,V> subMap(K fromKey, K toKey);
  196.     /**
  197.      * 返回一个键值小于toKey的子Map
  198.      *
  199.      * <p>Equivalent to {@code headMap(toKey, false)}.
  200.      */
  201.     SortedMap<K,V> headMap(K toKey);
  203.     /**
  204.      * 返回一个键值大于等于fromKey的子Map
  205.      *
  206.      * <p>Equivalent to {@code tailMap(fromKey, true)}.
  207.      *
  208.      */
  209.     SortedMap<K,V> tailMap(K fromKey);
  210. }

简单使用

TreeMap实现了NavigableMap，也就相当于实现了SortedMap，我们看一下TreeMap的简单使用

public class TreeMapCode {

    public static void main(String[] args) {
        Map<Integer,String> treeMap = new TreeMap();
        treeMap.put(1, "呵呵呵呵");
        treeMap.put(4, "呸呸呸呸");
        treeMap.put(2, "噢噢噢噢");
        treeMap.put(3, "哈哈哈哈");

        System.out.println("Map = "+treeMap);

        // 获取第一个元素
        Map.Entry<Integer, String> firstEntry = ((TreeMap<Integer, String>) treeMap).firstEntry();

        System.out.println("\n第一个元素 = "+firstEntry);

        // 获取最后一个元素
        Map.Entry<Integer, String> lastEntry = ((TreeMap<Integer, String>) treeMap).lastEntry();
        System.out.println("\n最后一个元素 = "+lastEntry);

        // 截取Map
        SortedMap<Integer, String> subMap = ((TreeMap<Integer, String>) treeMap).subMap(2, 4);
        System.out.println("\n截取2-4之间的子Map = "+subMap);

        // 获取key值小于3的最大映射
        Map.Entry<Integer, String> lowerEntry = ((TreeMap<Integer, String>) treeMap).lowerEntry(3);
        System.out.println("\nkey小于3的最大映射 = "+lowerEntry);

        // 获取key值大于2的最小映射
        Map.Entry<Integer, String> higherEntry = ((TreeMap<Integer, String>) treeMap).higherEntry(2);
        System.out.println("\nkey大于2的最小映射 = "+higherEntry);

        // 倒序排列后返回
        NavigableMap<Integer, String> descendingMap = ((TreeMap<Integer, String>) treeMap).descendingMap();
        System.out.println("\n倒序排列后的Map = "+descendingMap);

    }
}

执行结果：
image.png

总结

1、SortedMap直接继承了Map接口，提供了若干个与排序相关的方法，如获取最大最小key值等

2、NavigableMap继承了SortedMap接口，主要扩展了一些便于匹配的导航方法，且主要是为了查找而不是遍历

3、TreeMap实现了NavigableMap，也就相当于实现了SortedMap，是比较常用的有序Map实现。