Java 容器KV（一）- Map

Map定义

Map 是 Key-Value 对映射的抽象接口，该映射不包括重复的键，即一个键对应一个值。Map的key也可以为null，也不可重复。

Map接口

public interface Map<K,V> {
    // 查询操作
    /**
     * 返回键值对数量
     */
    int size();
    /**
     * Map是否为空
     */
    boolean isEmpty();
    /**
     * Map中是否包含指定的key
     */
    boolean containsKey(Object key);
    /**
     * Map中是否包含指定的value
     */
    boolean containsValue(Object value);
    /**
     * 根据key获取对应的value
     */
    V get(Object key);
    
    // Modification Operations
    /**
     * 插入键值对，如果Map中已经存在该key，则新的value会覆盖原来的value
     */
    V put(K key, V value);
    /**
     * 移除指定key对应的键值对，并返回相应的value
     */
    V remove(Object key);
    // 批量操作
    /**
     * 将另一个Map中的键值对全部复制过来
     */
    void putAll(Map<? extends K, ? extends V> m);
    /**
     * 移除所有键值对
     */
    void clear();
    // 视图
    /**
     * 返回包含Map中所有key的（Set类型）键视图，对Map的修改也会影响到键视图
     */
    Set<K> keySet();
    /**
     * 返回包含Map中所有value的（Collection类型）值视图，对Map的修改也会影响到值视图
     */
    Collection<V> values();
    /**
     * 返回包含Map中所有键值对的（java.util.Map.Entry类型）键值对视图
     */
    Set<Map.Entry<K, V>> entrySet();
    /**
     * Map 键值对接口
     */
    interface Entry<K,V> {
        /**
         * 返回键
         */
        K getKey();
        /**
         * 返回值
         */
        V getValue();
        /**
         * 设置键
         */
        V setValue(V value);
        boolean equals(Object o);
        int hashCode();
        /**
         * 键比较器（内部比较器）
         */
        public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                    (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }
        /**
         * 值比较器（内部比较器）
         */
        public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                    (c1, c2) -> c1.getValue().compareTo(c2.getValue());
        }
        /**
         * 键比较器（外部比较器）
         */
        public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                    (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
        }
        /**
         * 值比较器（外部比较器）
         */
        public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                    (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
        }
    }
    // 比较和散列
    boolean equals(Object o);
    int hashCode();
}

SortedMap

SortedMap规定了元素在Map中的排序功能.

public interface SortedMap<K,V> extends Map<K,V> {

 // key的比较器
 Comparator<? super K> comparator();
 
 // 返回fromKey（包含）到toKey（不包含）之间的元素组成的子map
 SortedMap<K,V> subMap(K fromKey, K toKey);
 
 // 返回小于toKey（不包含）的子map
 SortedMap<K,V> headMap(K toKey);
 
 // 返回大于等于fromKey（包含）的子map
 SortedMap<K,V> tailMap(K fromKey);
 
 // 返回最小的key
 K firstKey();
 
 // 返回最大的key
 K lastKey();
 
 // 返回key集合
 Set<K> keySet();
 
 // 返回value集合
 Collection<V> values();
 
 // 返回节点集合
 Set<Map.Entry<K, V>> entrySet();
}

NavigableMap

public interface NavigableMap<K,V> extends SortedMap<K,V> {

 // 小于给定key的最大节点
 Map.Entry<K,V> lowerEntry(K key);
 
 // 小于给定key的最大key
 K lowerKey(K key);
 
 // 小于等于给定key的最大节点
 Map.Entry<K,V> floorEntry(K key);
 
 // 小于等于给定key的最大key
 K floorKey(K key);
 
 // 大于等于给定key的最小节点
 Map.Entry<K,V> ceilingEntry(K key);
 
 // 大于等于给定key的最小key
 K ceilingKey(K key);
 
 // 大于给定key的最小节点
 Map.Entry<K,V> higherEntry(K key);
 
 // 大于给定key的最小key
 K higherKey(K key);
 
 // 最小的节点
 Map.Entry<K,V> firstEntry();
 
 // 最大的节点
 Map.Entry<K,V> lastEntry();
 
 // 弹出最小的节点
 Map.Entry<K,V> pollFirstEntry();
 
 // 弹出最大的节点
 Map.Entry<K,V> pollLastEntry();
 
 // 返回倒序的map
 NavigableMap<K,V> descendingMap();
 
 // 返回有序的key集合
 NavigableSet<K> navigableKeySet();
 
 // 返回倒序的key集合
 NavigableSet<K> descendingKeySet();
 
 // 返回从fromKey到toKey的子map，是否包含起止元素可以自己决定
 NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
 K toKey, boolean toInclusive);
 
 // 返回小于toKey的子map，是否包含toKey自己决定
 NavigableMap<K,V> headMap(K toKey, boolean inclusive);
 
 // 返回大于fromKey的子map，是否包含fromKey自己决定
 NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
 
 // 等价于subMap(fromKey, true, toKey, false)
 SortedMap<K,V> subMap(K fromKey, K toKey);
 
 // 等价于headMap(toKey, false)
 SortedMap<K,V> headMap(K toKey);
 
 // 等价于tailMap(fromKey, true)
 SortedMap<K,V> tailMap(K fromKey);
}