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