今天來了解下 AbstractMap。

什麼是 AbstractMap

AbstractMap 是 Map 介面的的實現類之一，也是 HashMap, TreeMap, ConcurrentHashMap 等類的父類。

AbstractMap 提供了 Map 的基本實現，使得我們以後要實現一個 Map 不用從頭開始，只需要繼承 AbstractMap, 然後按需求實現/重寫對應方法即可。

AbstarctMap 中唯一的抽象方法：

public abstract Set<Entry<K,V>> entrySet();

當我們要實現一個 不可變

如果想要實現一個 可變的 Map,我們需要在上述操作外，重寫 put() 方法，因為 預設不支援 put 操作：

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

而且 entrySet() 返回的 Set 的迭代器，也得實現 remove() 方法，因為 AbstractMap 中的 刪除相關操作都需要呼叫該迭代器的 remove() 方法。

• 一種是不含引數的，返回一個空 map
• 一種是以一個 map 為引數，返回一個和引數內容一樣的 map

AbstractMap 的成員變數

transient volatile Set<K>        keySet;
transient volatile Collection<V> values;

有兩個成員變數：

• keySet, 儲存 map 中所有鍵的 Set
• values, 儲存 map 中所有值的集合

他們都是 transient, volatile, 分別表示不可序列化、併發環境下變數的修改能夠保證執行緒可見性。

需要注意的是 volatile 只能保證可見性，不能保證原子性，需要保證操作是原子性操作，才能保證使用 volatile 關鍵字的程式在併發時能夠正確執行。

AbstractMap 的成員方法

AbstractMap 中實現了許多方法，實現類會根據自己不同的要求選擇性的覆蓋一些。

接下來根據看看 AbstractMap 中的方法。

1.新增

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

public void putAll(Map<? extends K, ? extends V> m) {
    for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
        put(e.getKey(), e.getValue());
}

可以看到預設是不支援新增操作的，實現類需要重寫 put() 方法。

2.刪除

public V remove(Object key) {
    //獲取儲存 Map.Entry 集合的迭代器
    Iterator<Entry<K,V>> i = entrySet().iterator();
    Entry<K,V> correctEntry = null;
    //遍歷查詢，當某個 Entry 的 key 和 指定 key 一致時結束
    if (key==null) {
        while (correctEntry==null && i.hasNext()) {
            Entry<K,V> e = i.next();
            if (e.getKey()==null)
                correctEntry = e;
        }
    } else {
        while (correctEntry==null && i.hasNext()) {
            Entry<K,V> e = i.next();
            if (key.equals(e.getKey()))
                correctEntry = e;
        }
    }

    //找到了，返回要刪除的值
    V oldValue = null;
    if (correctEntry !=null) {
        oldValue = correctEntry.getValue();
        //呼叫迭代器的 remove 方法
        i.remove();
    }
    return oldValue;
}

//呼叫 Set.clear() 方法清除
public void clear() {
    entrySet().clear();
}

3.獲取

//時間複雜度為 O(n)
//許多實現類都重寫了這個方法
public V get(Object key) {
    //使用 Set 迭代器進行遍歷，根據 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;
}

4.查詢狀態

//是否存在指定的 key
//時間複雜度為 O(n)
//許多實現類都重寫了這個方法
public boolean containsKey(Object key) {
    //還是迭代器遍歷，查詢 key，跟 get() 很像啊
    Iterator<Map.Entry<K,V>> i = entrySet().iterator();
    if (key==null) {
        while (i.hasNext()) {
            Entry<K,V> e = i.next();
            //getKey()
            if (e.getKey()==null)
                return true;
        }
    } else {
        while (i.hasNext()) {
            Entry<K,V> e = i.next();
            if (key.equals(e.getKey()))
                return true;
        }
    }
    return false;
}


//查詢是否存在指定的值
public boolean containsValue(Object value) {
    Iterator<Entry<K,V>> i = entrySet().iterator();
    if (value==null) {
        while (i.hasNext()) {
            Entry<K,V> e = i.next();
            //getValue()
            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 int size() {
    //使用 Set.size() 獲取元素個數
    return entrySet().size();
}

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

5.用於比較的 equals(), hashCode()

//內部用來測試 SimpleEntry, SimpleImmutableEntry 是否相等的方法
private static boolean eq(Object o1, Object o2) {
    return o1 == null ? o2 == null : o1.equals(o2);
}

//判斷指定的物件是否和當前 Map 一致
//為什麼引數不是泛型而是 物件呢
//據說是建立這個方法時還沒有泛型 - -
public boolean equals(Object o) {
    //引用指向同一個物件
    if (o == this)
        return true;

    //必須是 Map 的實現類
    if (!(o instanceof Map))
        return false;
    //強轉為 Map
    Map<?,?> m = (Map<?,?>) o;
    //元素個數必須一致
    if (m.size() != size())
        return false;

    try {
        //還是需要一個個遍歷，對比
        Iterator<Entry<K,V>> i = entrySet().iterator();
        while (i.hasNext()) {
            //對比每個 Entry 的 key 和 value
            Entry<K,V> e = i.next();
            K key = e.getKey();
            V value = e.getValue();
            if (value == null) {
                //對比 key, value
                if (!(m.get(key)==null && m.containsKey(key)))
                    return false;
            } else {
                if (!value.equals(m.get(key)))
                    return false;
            }
        }
    } catch (ClassCastException unused) {
        return false;
    } catch (NullPointerException unused) {
        return false;
    }

    return true;
}

//整個 map 的 hashCode() 
public int hashCode() {
    int h = 0;
    //是所有 Entry 雜湊值的和
    Iterator<Entry<K,V>> i = entrySet().iterator();
    while (i.hasNext())
        h += i.next().hashCode();
    return h;
}

6.獲取三個主要的檢視

獲取所有的鍵:

public Set<K> keySet() {
    //如果成員變數 keySet 為 null,建立個空的 AbstractSet
    if (keySet == null) {
        keySet = new AbstractSet<K>() {
            public Iterator<K> iterator() {
                return new Iterator<K>() {
                    private Iterator<Entry<K,V>> i = entrySet().iterator();

                    public boolean hasNext() {
                        return i.hasNext();
                    }

                    public K next() {
                        return i.next().getKey();
                    }

                    public void remove() {
                        i.remove();
                    }
                };
            }

            public int size() {
                return AbstractMap.this.size();
            }

            public boolean isEmpty() {
                return AbstractMap.this.isEmpty();
            }

            public void clear() {
                AbstractMap.this.clear();
            }

            public boolean contains(Object k) {
                return AbstractMap.this.containsKey(k);
            }
        };
    }
    return keySet;
}

獲取所有的值:

public Collection<V> values() {
    if (values == null) {
        //沒有就建立個空的 AbstractCollection 返回
        values = new AbstractCollection<V>() {
            public Iterator<V> iterator() {
                return new Iterator<V>() {
                    private Iterator<Entry<K,V>> i = entrySet().iterator();

                    public boolean hasNext() {
                        return i.hasNext();
                    }

                    public V next() {
                        return i.next().getValue();
                    }

                    public void remove() {
                        i.remove();
                    }
                };
            }

            public int size() {
                return AbstractMap.this.size();
            }

            public boolean isEmpty() {
                return AbstractMap.this.isEmpty();
            }

            public void clear() {
                AbstractMap.this.clear();
            }

            public boolean contains(Object v) {
                return AbstractMap.this.containsValue(v);
            }
        };
    }
    return values;
}

獲取所有鍵值對，需要子類實現：

public abstract Set<Entry<K,V>> entrySet();

AbstractMap 中的內部類

正如 Map 介面 中有內部類 Map.Entry 一樣， AbstractMap 也有兩個內部類：

• SimpleImmutableEntry, 表示一個不可變的鍵值對
• SimpleEntry, 表示可變的鍵值對

SimpleImmutableEntry，不可變的鍵值對,實現了 Map.Entry < K,V> 介面：

public static class SimpleImmutableEntry<K,V>
    implements Entry<K,V>, java.io.Serializable
{
    private static final long serialVersionUID = 7138329143949025153L;
    //key-value
    private final K key;
    private final V value;

    //建構函式，傳入 key 和 value
    public SimpleImmutableEntry(K key, V value) {
        this.key   = key;
        this.value = value;
    }

    //建構函式2，傳入一個 Entry，賦值給本地的 key 和 value
    public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
        this.key   = entry.getKey();
        this.value = entry.getValue();
    }

    //返回 鍵
    public K getKey() {
        return key;
    }

    //返回 值
    public V getValue() {
        return value;
    }

    //修改值，不可修改的 Entry 預設不支援這個操作
    public V setValue(V value) {
        throw new UnsupportedOperationException();
    }

    //比較指定 Entry 和本地是否相等
    //要求順序，key-value 必須全相等
    //只要是 Map 的實現類即可，不同實現也可以相等
    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());
    }

    //返回一個 String
    public String toString() {
        return key + "=" + value;
    }

}

SimpleEntry, 可變的鍵值對:

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;
    }

}

SimpleEntry 與 SimpleImmutableEntry 唯一的區別就是支援 setValue() 操作。

總結

常用的幾種 Map, 比如 HashMap, TreeMap, LinkedHashMap 都繼承自它。

Thanks

還有肉肉做的紫菜包飯，讓我今天能量十足！