jdk1.8.0_45源码解读——Map接口和AbstractMap抽象类的实现
jdk1.8.0_45源码解读——Map接口和AbstractMap抽象类的实现
一、 Map架构
如上图：
(01) Map 是映射接口，Map中存储的内容是键值对(key-value)。
(02) AbstractMap 是继承于Map的抽象类，它实现了Map中的大部分API。其它Map的实现类可以通过继承AbstractMap来减少重复编码。
(03) SortedMap 是继承于Map的接口。SortedMap中的内容是排序的键值对，排序的方法是通过比较器(Comparator)。
(04) NavigableMap 是继承于SortedMap的接口。相比于SortedMap，NavigableMap有一系列的导航方法；如"获取大于/等于某对象的键值对"、“获取小于/等于某对象的键值对”等等。
(05) TreeMap 继承于AbstractMap，且实现了NavigableMap接口；因此，TreeMap中的内容是“有序的键值对”！
(06) HashMap 继承于AbstractMap，但没实现NavigableMap接口；因此，HashMap的内容是“键值对，但不保证次序”！
(07) Hashtable 虽然不是继承于AbstractMap，但它继承于Dictionary(Dictionary也是键值对的接口)，而且也实现Map接口；因此，Hashtable的内容也是“键值对，也不保证次序”。但和HashMap相比，Hashtable是线程安全的，而且它支持通过Enumeration去遍历。
(08) WeakHashMap 继承于AbstractMap。它和HashMap的键类型不同，WeakHashMap的键是“弱键”。
二、 Map接口
1. Map.Entry<K, V>的结构
映射项（键-值对）。Map.entrySet() 方法返回映射的 collection 视图，其中的元素属于此类。获得映射项引用的唯一 方法是通过此 collection 视图的迭代器来实现。这些 Map.Entry 对象仅在迭代期间有效；更确切地讲，如果在迭代器返回项之后修改了底层映射，则某些映射项的行为是不确定的，除了通过 setValue 在映射项上执行操作之外。
K getKey(); //返回此项中对应的键值 V getValue(); //返回此项中对应的值 V setValue(V value); //用指定的值替换与此项对应的值 boolean equals(Object o); //比较指定对象与此项的相等性 int hashCode(); //返回此项的哈希码
2. Map接口
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序 定义为迭代器在映射的 collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。
注：将可变对象用作映射键时必须格外小心。当对象是映射中某个键时，如果以影响 equals 比较的方式更改了对象的值，则映射的行为将是不确定的。此项禁止的一种特殊情况是不允许某个映射将自身作为一个键包含。虽然允许某个映射将自身作为值包含，但请格外小心：在这样的映射上 equals 和 hashCode 方法的定义将不再是明确的。
public interface Map<K,V> { int size(); boolean isEmpty(); boolean containsKey(Object key); boolean containsValue(Object value); V get(Object key); V put(K key, V value); V remove(Object key); void putAll(Map<? extends K, ? extends V> m); void clear(); Set<K> keySet(); Collection<V> values(); //返回此映射中包含的映射关系的 set 视图 Set<Map.Entry<K, V>> entrySet(); boolean equals(Object o); int hashCode(); }
三、AbstractMap抽象类
1. AbstractMap.SimpleEntry<K, V>的结构
SimpleEntry<K, V>是维护键和值的 Entry。可以使用 setValue() 方法更改值。此类简化了构建自定义映射实现的过程。例如，可以使用 Map.entrySet().toArray 方法方便地返回 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; } //相等性检测，包括null值 private static boolean eq(Object o1, Object o2) { return o1 == null ? o2 == null : o1.equals(o2); } //比较指定对象与此项的相等性 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()); } //返回此映射项的哈希值:key值的哈希码与value值的哈希码按位异或的结果 public int hashCode() { return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode()); } //返回此映射项的 String表示形式:key=value public String toString() { return key + "=" + value; } }
2.AbstractMap.SimpleImmutableEntry<K,V>的结构
SimpleImmutableEntry<K,V>是维护不可变的键和值的 Entry，不支持setValue()方法。方便用于在返回线程安全的键-值映射关系的方法。
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; } //该方法仅抛出UnsupportedOperationException，表明该Entry不支持setValue方法 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()); } //返回此映射项的哈希值:key值的哈希码与value值的哈希码按位异或的结果 public int hashCode() { return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode()); } //返回此映射项的 String表示形式:key=value public String toString() { return key + "=" + value; } }
3. AbstractMap抽象类
AbstractMap类提供 Map接口的骨干实现，以最大限度地减少实现此接口所需的工作。
要实现不可修改的映射，编程人员只需扩展此类并提供 entrySet() 方法的实现即可，该方法将返回映射的映射关系 set视图。通常，返回的 set
将依次在 AbstractSet 上实现。此 set不支持 add() 或 remove() 方法，其迭代器也不支持 remove()
方法。
要实现可修改的映射，编程人员必须另外重写此类的put() 方法（否则将抛出 UnsupportedOperationException），entrySet().iterator() 返回的迭代器也必须另外实现其 remove() 方法。
public abstract class AbstractMap<K,V> implements Map<K,V> { //构造函数 protected AbstractMap() { } //返回此映射中的键-值映射关系数 public int size() { return entrySet().size(); } //如果此映射未包含键-值映射关系，则返回 true。 public boolean isEmpty() { return size() == 0; } //如果键值对<key,value>集合中包含指定的value值,则返回ture public boolean containsValue(Object value) { //entrySet()返回此映射中包含的映射关系的Set视图 Iterator<Entry<K,V>> i = entrySet().iterator(); //Map中允许value值为null，故分两种情况考虑 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; } //如果键值对<key,value>集合中包含指定的key值,则返回ture public boolean containsKey(Object key) { //entrySet()返回此映射中包含的映射关系的Set视图 Iterator<Map.Entry<K,V>> i = entrySet().iterator(); //Map中只允许有唯一一个null的key值，故分两种情况考虑 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; } //返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null 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; } //将指定的值与此映射中的指定键关联 public V put(K key, V value) { throw new UnsupportedOperationException(); } /** * 如果存在一个键的映射关系，则将其从此映射中移除。并返回以前与key关联的值；如果没有key的映射关系，则返回null * * 注意，如果 entrySet()返回的集合所调用的迭代器不支持 remove方法，并且此映射包含指定键的映射关系， * 则此实现将抛出 UnsupportedOperationException。 */ public V remove(Object key) { Iterator<Entry<K,V>> i = entrySet().iterator(); Entry<K,V> correctEntry = null; //用于指向给定键值对应的映射关系 //找到指定键的映射关系，并赋值给correctEntry 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(); //得到以前与key关联的值 i.remove(); //运用迭代器中的remove()方法来对得到的键值对项进行移除工作 } return oldValue; } //从指定Map中将所有映射关系<key,value>复制到此映射中 public void putAll(Map<? extends K, ? extends V> m) { for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) put(e.getKey(), e.getValue()); } //从此映射中移除所有映射关系 public void clear() { entrySet().clear(); } //用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量最后修改后的值 transient volatile Set<K> keySet; //Map中key值的唯一性决定键值集合的视图类型为Set transient volatile Collection<V> values; //Map中value值的可重复性决定值集合的视图类型为Collection //返回此映射中包含的键的 Set视图 public Set<K> keySet() { 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; } //返回此映射中包含的值的 Collection视图 public Collection<V> values() { 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(); //得到value值 } 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; } //返回此映射中包含的映射关系的 Set 视图 public abstract Set<Entry<K,V>> entrySet(); //比较指定对象与此映射的相等性 public boolean equals(Object o) { //如果给定对象也是一个映射并且两个映射表示相同的映射关系，则返回true if (o == this) return true; //检查指定的对象是否为映射关系 if (!(o instanceof Map)) return false; Map<?,?> m = (Map<?,?>) o; //强制类型转换 //检查指定的对象是否是一个大小与此映射相等的映射 if (m.size() != size()) return false; //在此映射 entrySet()返回的collection上进行迭代，并检查指定的映射是否包含此映射所包含的每个映射关系 try { Iterator<Entry<K,V>> i = entrySet().iterator(); while (i.hasNext()) { Entry<K,V> e = i.next(); K key = e.getKey(); //此映射的key值 V value = e.getValue(); //此映射的value值 if (value == null) { 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的哈希码被定义为该映射的 entrySet()视图中每个条目的哈希码之和。这确保了 m1.equals(m2)对于任意两个映射m1和m2都意味着 m1.hashCode()==m2.hashCode() public int hashCode() { int h = 0; Iterator<Entry<K,V>> i = entrySet().iterator(); while (i.hasNext()) h += i.next().hashCode(); return h; } //返回此映射的字符串表示形式:{key1=value1}, {key1=value1}, ... public String toString() { Iterator<Entry<K,V>> i = entrySet().iterator(); if (! i.hasNext()) //Map为null 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(' '); } } //返回此 AbstractMap 实例的浅表副本：不复制键和值本身 protected Object clone() throws CloneNotSupportedException { AbstractMap<?,?> result = (AbstractMap<?,?>)super.clone(); result.keySet = null; result.values = null; return result; } }
