java 集合框架 Map-AbstractMap

Map接口

1. 鍵值對映射（key-value）,對於一個map，每個key都是唯一的，不重複，而且每個key對應一個value，value可以重複
2. 需要注意可變對象作爲key，key對象是否相等，是使用equal方法判斷的，如果可變對象改變的狀態導致equal方法結果改變，那麼映射的錯誤是未知、不確定的；因此，映射最好使用不可變對象爲key,如基本類型、String等；
3. 映射是否有序，Map接口沒有規定，由實現類確定
4. Map接口規定，實現類都需要有兩個構造方法：無參構造方法，一個map參數構造方法，雖然Map在接口層沒有辦法強制子類的構造方法，但是java集合框架中的map子類都是遵循這個規則的
5. key和value是否可以爲null值，由具體的子類確定
   6.Map提供3個數據視圖：keySet、values、entrySet，分別爲映射的key集合(set)，映射的value集合(Collection)，以及映射集合(entry)
   7.Map接口內定義了entrySet的接口Entry

AbstractMap

與AbstractList一樣，AbstractMap實現了部分通用的方法，在集合框架中幾乎所有的Map實現類都是繼承AbstractMap抽象類
在AbstractList中實現的通用方法是基於迭代器的，而AbstractMap是基於entrySet與其迭代器的，下面我們看下部分實現的源碼：

    public int size() {
        return entrySet().size();
    }

    public boolean isEmpty() {
        return size() == 0;
    }    

    public boolean containsValue(Object value) {
        Iterator<Entry<K,V>> i = entrySet().iterator();
        if (value==null) {
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
                if (e.getValue()==null)
                    return true;
            }
        } else {
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
                if (value.equals(e.getValue()))
                    return true;
            }
        }
        return false;
    }

    public V get(Object key) {
        Iterator<Entry<K,V>> i = entrySet().iterator();
        if (key==null) {
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
                if (e.getKey()==null)
                    return e.getValue();
            }
        } else {
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
                if (key.equals(e.getKey()))
                    return e.getValue();
            }
        }
        return null;
    }

get、containsValue 的實現與List的相識，使用entrySet的迭代器循環判斷每一個value，這種方式還是比較低效的，看後續的子類是否有不同的方法實現

對Map接口的EntrySet內部接口，AbstractMap簡單實現了：

    public static class SimpleEntry<K,V>
        implements Entry<K,V>, java.io.Serializable
    {
        private static final long serialVersionUID = -8499721149061103585L;

        private final K key;
        private V value;

        public SimpleEntry(K key, V value) {
            this.key   = key;
            this.value = value;
        }

        public SimpleEntry(Entry<? extends K, ? extends V> entry) {
            this.key   = entry.getKey();
            this.value = entry.getValue();
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        public V setValue(V value) {
            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }

        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            return eq(key, e.getKey()) && eq(value, e.getValue());
        }

        public int hashCode() {
            return (key   == null ? 0 :   key.hashCode()) ^
                   (value == null ? 0 : value.hashCode());
        }

        public String toString() {
            return key + "=" + value;
        }

    }

可以看出，這個實現還是比較簡單的吧，就是保存兩個變量：key、value，以及簡單實現操作方法

這裏還有一些實現了的方法，但是隻是拋出一個UnsupportedOperationException：

    public V put(K key, V value) {
        throw new UnsupportedOperationException();
    }

以及在實現的一個不可變Entry：SimpleImmutableEntry 中的set方法：

        public V setValue(V value) {
            throw new UnsupportedOperationException();
        }

在抽象類中實現了接口方法，但是又不無實際操作而是拋出異常，而這些方法都是改變容器數據的方法，所有我認爲這些實現是爲了子類實現’不可變’特性，繼承AbstractMap的子類，如果沒有重寫put方法，那麼這個子類就是不可修改的，這樣的例子如：java.util.Collections.SingletonMap