JDK源码解析---AbstractMap

1.概述

AbstractMap 是 Map接口的的实现类之一，也是 HashMap, TreeMap, ConcurrentHashMap 等类的父类。

AbstractMap 提供了 Map 的基本实现，使得我们以后要实现一个 Map 不用从头开始，只需要继承 AbstractMap, 然后按需求实现/重写对应方法即可。

2.类图

仅实现了Map接口，Map接口定义了一些关于map集合的基本操作。AbstractMap需要实现定义的这些基本操作。

3.属性

volatile保证了可见性，当一个线程写的时候，其他读线程可以获得到写后的结果。但不能保证原子性。所以其一些子类是不能保证线程安全的。例如HashMap是不安全的。

transient volatile Set<K>        keySet;//记录了所有的key
transient volatile Collection<V> values;//记录了所有的值value

4.构造方法

提供了一个无参的构造函数 并且是protected修饰的，需要子类去重写该构造方法。

protected AbstractMap() {
}

5.基本方法

public int size() {//获得键值对的数量，直接返回的是key集合的大小。
    return entrySet().size();
}

public boolean isEmpty() {//判断是否为空，内部调用上述的方法若等于0则为空
    return size() == 0;
}

public boolean containsValue(Object value) {//判断value是否存在
    Iterator<Entry<K,V>> i = entrySet().iterator();//得到关于key-value集合的迭代器
    if (value==null) {//若参数为null
        while (i.hasNext()) {//迭代元素
            Entry<K,V> e = i.next();
            if (e.getValue()==null)//得到的对应的value为空 返回true
                return true;
        }
    } else {//参数不为null
        while (i.hasNext()) {//迭代元素
            Entry<K,V> e = i.next();
            if (value.equals(e.getValue()))//得到对应的value和参数重的value相同 返回true
                return true;
        }
    }
    return false;//否则返回false
}

public boolean containsKey(Object key) {//判断key是否存在
    Iterator<Map.Entry<K,V>> i = entrySet().iterator();//同理使用迭代器，下面过程和上面的过程类似，不赘述
    if (key==null) {
        while (i.hasNext()) {
            Entry<K,V> e = i.next();
            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 V get(Object key) {//获得key对应的value 过程和上面类似 只是返回值的不同
    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;
}

public V put(K key, V value) {//没有具体的实现。若子类需要使用可变的Map，则需要实现这个方法，否则调用put会抛出异常。
    throw new UnsupportedOperationException();
}

public V remove(Object key) {//移除key以及其对应的value，并返回value值
    Iterator<Entry<K,V>> i = entrySet().iterator();//获得迭代器
    Entry<K,V> correctEntry = null;//用于存储寻找到的key-value
    if (key==null) {//若key为空
        while (correctEntry==null && i.hasNext()) {//迭代
            Entry<K,V> e = i.next();
            if (e.getKey()==null)//若找到了key为空的结点，将其记录下来
                correctEntry = e;
        }
    } else {//若key不为空
        while (correctEntry==null && i.hasNext()) {//迭代
            Entry<K,V> e = i.next();
            if (key.equals(e.getKey()))//若找到了key和参数key相同的结点，记录下来
                correctEntry = e;
        }
    }

    V oldValue = null;//记录旧值
    if (correctEntry !=null) {
        oldValue = correctEntry.getValue();//得到key对应的value，记录下来
        i.remove();//从集合中删去该键值对
    }
    return oldValue;//返回旧值
}

public void putAll(Map<? extends K, ? extends V> m) {//将参数m中的元素添加到集合中。
    for (Map.Entry<? extends K, ? extends V> e : m.entrySet())//迭代结点
        put(e.getKey(), e.getValue());//键值对依次添加到集合中。
}

public void clear() {//清空集合map
    entrySet().clear();
}

public Set<K> keySet() {//获得key的集合，若keySet为空，则new一个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() {//获得value的集合，若为空 则new一个AbstractCollection
    if (values == null) {
        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();//唯一的抽象方法，子类需要去实现，获得Entry的集合

public boolean equals(Object o) {//比较两个Map是否相等
    if (o == this)//若是本身返回true
        return true;

    if (!(o instanceof Map))//若参数类型不是Map返回false
        return false;
    Map<?,?> m = (Map<?,?>) o;//强制转换成Map
    if (m.size() != size())//若大小不想等返回false
        return false;

    try {
        Iterator<Entry<K,V>> i = entrySet().iterator();//获得迭代器
        while (i.hasNext()) {//迭代集合中每一个结点。
            Entry<K,V> e = i.next();
            K key = e.getKey();
            V value = e.getValue();
            if (value == null) {
                if (!(m.get(key)==null && m.containsKey(key)))//若集合m中不存在这个key则返回false
                    return false;
            } else {//若存在key但是对应的value不同则返回false
                if (!value.equals(m.get(key)))
                    return false;
            }
        }
    } catch (ClassCastException unused) {
        return false;
    } catch (NullPointerException unused) {
        return false;
    }

    return true;
}

public int hashCode() {//计算hash值
    int h = 0;
    Iterator<Entry<K,V>> i = entrySet().iterator();
    while (i.hasNext())
        h += i.next().hashCode();//迭代每一个结点的hash值累加
    return h;
}

public String toString() {//返回字符串描述
    Iterator<Entry<K,V>> i = entrySet().iterator();
    if (! i.hasNext())//空集合
        return "{}";

    StringBuilder sb = new StringBuilder();
    sb.append('{');
    for (;;) {
        Entry<K,V> e = i.next();
        K key = e.getKey();
        V value = e.getValue();
        sb.append(key   == this ? "(this Map)" : key);
        sb.append('=');
        sb.append(value == this ? "(this Map)" : value);
        if (! i.hasNext())
            return sb.append('}').toString();
        sb.append(',').append(' ');
    }
}

protected Object clone() throws CloneNotSupportedException {//返回一个clone的集合，只是克隆类型，不克隆里面的key和value
    AbstractMap<?,?> result = (AbstractMap<?,?>)super.clone();
    result.keySet = null;
    result.values = null;
    return result;
}

private static boolean eq(Object o1, Object o2) {//判断两个对象是否相同
    return o1 == null ? o2 == null : o1.equals(o2);
}

6.简单的Entry实现

HashMap中的每一项起始就是一个Entry 包括了键和值

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

}

不可以变的Entry set方法没有具体的实现，调用的话直接抛出异常

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

    private final K key;
    private final V value;

    public SimpleImmutableEntry(K key, V value) {
        this.key   = key;
        this.value = 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;
    }

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

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

}