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);
}
网友评论