Java源码之Map

     /**
     * Returns the number of key-value mappings in this map.  If the
     * map contains more than Integer.MAX_VALUE elements, returns
     * Integer.MAX_VALUE.
     *
     * @return the number of key-value mappings in this map
     */
    int size();

int size();
返回map中key-value的数量，若超过最大值，则返回最大值

    /**
     * Returns true if this map contains no key-value mappings.
     *
     * @return true if this map contains no key-value mappings
     */
    boolean isEmpty();

boolean isEmpty();
如果map中不包含key-value值，返回true

    /**
     * Returns true if this map contains a mapping for the specified
     * key.  More formally, returns true if and only if
     * this map contains a mapping for a key k such that
     * (key==null ? k==null : key.equals(k)).  (There can be
     * at most one such mapping.)
     *
     * @param key key whose presence in this map is to be tested
     * @return true if this map contains a mapping for the specified
     *         key
     * @throws ClassCastException if the key is of an inappropriate type for
     *         this map
     * (optional)
     * @throws NullPointerException if the specified key is null and this map
     *         does not permit null keys
     * (optional)
     */
    boolean containsKey(Object key);

boolean containsKey(Object key);
如果map中包含指定的key，则返回true
最多只能包含一个此种方式的映射：(keynull ? knull : key.equals(k))
异常：
ClassCastException：如果key在map中属于异常类型
NullPointerException：key如果为null并且此map中不允许包含null

    /**
     * Returns true if this map maps one or more keys to the
     * specified value.  More formally, returns true if and only if
     * this map contains at least one mapping to a value v such that
     * (value==null ? v==null : value.equals(v)).  This operation
     * will probably require time linear in the map size for most
     * implementations of the Map interface.
     *
     * @param value value whose presence in this map is to be tested
     * @return true if this map maps one or more keys to the
     *         specified value
     * @throws ClassCastException if the value is of an inappropriate type for
     *         this map
     * (optional)
     * @throws NullPointerException if the specified value is null and this
     *         map does not permit null values
     * (optional)
     */
    boolean containsValue(Object value);

boolean containsValue(Object value);
如果map中存在一个或多个此value的值，则返回true
对于大多数的map接口实现，此操作可能需要实现一次此map长度的线性操作时间（指此方法需要遍历map中的所有key-value，执行时间比较长）
异常：
ClassCastException：如果value在map中属于异常类型
NullPointerException：value如果为null并且此map中不允许包含null

    /**
     * Returns the value to which the specified key is mapped,
     * or {@code null} if this map contains no mapping for the key.
     *
     * 
More formally, if this map contains a mapping from a key
     * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
     * key.equals(k))}, then this method returns {@code v}; otherwise
     * it returns {@code null}.  (There can be at most one such mapping.)
     *
     * 
If this map permits null values, then a return value of
     * {@code null} does not necessarily indicate that the map
     * contains no mapping for the key; it's also possible that the map
     * explicitly maps the key to {@code null}.  The {@link #containsKey
     * containsKey} operation may be used to distinguish these two cases.
     *
     * @param key the key whose associated value is to be returned
     * @return the value to which the specified key is mapped, or
     *         {@code null} if this map contains no mapping for the key
     * @throws ClassCastException if the key is of an inappropriate type for
     *         this map
     * (optional)
     * @throws NullPointerException if the specified key is null and this map
     *         does not permit null keys
     * (optional)
     */
    V get(Object key);

get(Object key);
返回map中包含此value的key值，如果map中不包含此value的映射，返回null
注意：
如果此map中包含{(keynull ? knull : key.equals(k))}此种通过key给value赋值的方式（最多只能有一个此种映射）
此方法将会返回value的值，否则会返回null
如果map中允许存在null值，那么map中是否包含此value所对应的key将不再是必要的，此处可以很明确map中此value的key值为null，此操作的这两种情况需要注意区分。
异常：
ClassCastException：如果key在map中属于异常类型
NullPointerException：key如果为null并且此map中不允许包含null

    /**
     * Associates the specified value with the specified key in this map
     * (optional operation).  If the map previously contained a mapping for
     * the key, the old value is replaced by the specified value.  (A map
     * m is said to contain a mapping for a key k if and only
     * if {@link #containsKey(Object) m.containsKey(k)} would return
     * true.)
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @return the previous value associated with key, or
     *         null if there was no mapping for key.
     *         (A null return can also indicate that the map
     *         previously associated null with key,
     *         if the implementation supports null values.)
     * @throws UnsupportedOperationException if the put operation
     *         is not supported by this map
     * @throws ClassCastException if the class of the specified key or value
     *         prevents it from being stored in this map
     * @throws NullPointerException if the specified key or value is null
     *         and this map does not permit null keys or values
     * @throws IllegalArgumentException if some property of the specified key
     *         or value prevents it from being stored in this map
     */
    V put(K key, V value);

V put(K key, V value);
向map中关联指定的key和value，如果map中已存在key，则会将原有的value值覆盖

    /**
     * Removes the mapping for a key from this map if it is present
     * (optional operation).   More formally, if this map contains a mapping
     * from key k to value v such that
     * (key==null ?  k==null : key.equals(k)), that mapping
     * is removed.  (The map can contain at most one such mapping.)
     *
     * 
Returns the value to which this map previously associated the key,
     * or null if the map contained no mapping for the key.
     *
     * 
If this map permits null values, then a return value of
     * null does not necessarily indicate that the map
     * contained no mapping for the key; it's also possible that the map
     * explicitly mapped the key to null.
     *
     * 
The map will not contain a mapping for the specified key once the
     * call returns.
     *
     * @param key key whose mapping is to be removed from the map
     * @return the previous value associated with key, or
     *         null if there was no mapping for key.
     * @throws UnsupportedOperationException if the remove operation
     *         is not supported by this map
     * @throws ClassCastException if the key is of an inappropriate type for
     *         this map
     * (optional)
     * @throws NullPointerException if the specified key is null and this
     *         map does not permit null keys
     * (optional)
     */
    V remove(Object key);

V remove(Object key);
如果此map中存在这个key，那么移除此key的映射
如果此map中包含{(keynull ? knull : key.equals(k))}此种通过key给value赋值的方式（最多只能有一个此种映射）
此映射将会被移除
如果此ket不存在映射，将会返回null，否则会返回之前所关联的value值

    /**
     * Copies all of the mappings from the specified map to this map
     * (optional operation).  The effect of this call is equivalent to that
     * of calling {@link #put(Object,Object) put(k, v)} on this map once
     * for each mapping from key k to value v in the
     * specified map.  The behavior of this operation is undefined if the
     * specified map is modified while the operation is in progress.
     *
     * @param m mappings to be stored in this map
     * @throws UnsupportedOperationException if the putAll operation
     *         is not supported by this map
     * @throws ClassCastException if the class of a key or value in the
     *         specified map prevents it from being stored in this map
     * @throws NullPointerException if the specified map is null, or if
     *         this map does not permit null keys or values, and the
     *         specified map contains null keys or values
     * @throws IllegalArgumentException if some property of a key or value in
     *         the specified map prevents it from being stored in this map
     */
    void putAll(Map<? extends K, ? extends V> m);

void putAll(Map m);
将指定map中的所有映射复制到此map中
如果在进行此操作时，指定被复制的map同时在进行操作，那么此操作将会变得不明确
异常：
UnsupportedOperationException ：此map不允许putAll操作
ClassCastException：此map组织了指定map中key或value的值的存储
NullPointerException：指定的map存在null，但此map不允许
IllegalArgumentException：此map组织了指定map中key或value值的类型的存储

    /**
     * Removes all of the mappings from this map (optional operation).
     * The map will be empty after this call returns.
     *
     * @throws UnsupportedOperationException if the clear operation
     *         is not supported by this map
     */
    void clear();

void clear();
移除map中的所有映射（清空map）

    /**
     * Returns a {@link Set} view of the keys contained in this map.
     * The set is backed by the map, so changes to the map are
     * reflected in the set, and vice-versa.  If the map is modified
     * while an iteration over the set is in progress (except through
     * the iterator's own remove operation), the results of
     * the iteration are undefined.  The set supports element removal,
     * which removes the corresponding mapping from the map, via the
     * Iterator.remove, Set.remove,
     * removeAll, retainAll, and clear
     * operations.  It does not support the add or addAll
     * operations.
     *
     * @return a set view of the keys contained in this map
     */
    Set<K> keySet();

Set keySet();
返回此map中所包含所有的key的set
如果更改map或set任何一方，另一方同样会被更改