Map大家族的那点事儿(2) ：AbstractMap详解编程语言

AbstractMap是一个抽象类，它是Map接口的一个骨架实现，最小化实现了此接口提供的抽象函数。在Java的Collection框架中基本都遵循了这一规定，骨架实现在接口与实现类之间构建了一层抽象，其目的是为了复用一些比较通用的函数以及方便扩展，例如List接口拥有骨架实现AbstractList、Set接口拥有骨架实现AbstractSet等。

下面我们按照不同的操作类型来看看AbstractMap都实现了什么，首先是查询操作：

package java.util; 

import java.util.Map.Entry; 

public abstract class AbstractMap K,V implements Map K,V { 

 protected AbstractMap() { 

 // Query Operations 

 public int size() { 

 return entrySet().size(); 

 // 键值对的集合视图留给具体的实现类实现 

 public abstract Set Entry K,V entrySet(); 

 public boolean isEmpty() { 

 return size() == 0; 

 /** 

 * 遍历entrySet，然后逐个进行比较。 

 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; 

 /** 

 * 跟containsValue()同理，只不过比较的是key。 

 public boolean containsKey(Object 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; 

 /** 

 * 遍历entrySet，然后根据key取出关联的value。 

 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; 

}

可以发现这些操作都是依赖于函数entrySet()的，它返回了一个键值对的集合视图，由于不同的实现子类的Entry实现可能也是不同的，所以一般是在内部实现一个继承于AbstractSet且泛型为Map.Entry的内部类作为EntrySet，接下来是修改操作与批量操作：

// Modification Operations 

 * 没有提供实现，子类必须重写该方法，否则调用put()会抛出异常。 

public V put(K key, V value) { 

 throw new UnsupportedOperationException(); 

 * 遍历entrySet，先找到目标的entry，然后删除。 

 *（还记得之前说过的吗，集合视图中的操作也会影响到实际数据） 

public V remove(Object key) { 

 Iterator Entry K,V i = entrySet().iterator(); 

 Entry K,V correctEntry = null; 

 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(); 

 i.remove(); 

 return oldValue; 

// Bulk Operations 

 * 遍历参数m，然后将每一个键值对put到该Map中。 

public void putAll(Map ? extends K, ? extends V m) { 

 for (Map.Entry ? extends K, ? extends V e : m.entrySet()) 

 put(e.getKey(), e.getValue()); 

 * 清空entrySet等价于清空该Map。 

public void clear() { 

 entrySet().clear(); 

}

AbstractMap并没有实现put()函数，这样做是为了考虑到也许会有不可修改的Map实现子类继承它，而对于一个可修改的Map实现子类则必须重写put()函数。

AbstractMap没有提供entrySet()的实现，但是却提供了keySet()与values()集合视图的默认实现，它们都是依赖于entrySet()返回的集合视图实现的，源码如下：

/** 

 * keySet和values是lazy的，它们只会在第一次请求视图时进行初始化， 

 * 而且它们是无状态的，所以只需要一个实例（初始化一次）。 

transient Set K keySet; 

transient Collection V values; 

 * 返回一个AbstractSet的子类，可以发现它的行为都委托给了entrySet返回的集合视图 

 * 与当前的AbstractMap实例，所以说它自身是无状态的。 

public Set K keySet() { 

 Set K ks = keySet; 

 if (ks == null) { 

 ks = 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); 

 keySet = ks; 

 return ks; 

 * 与keySet()基本一致，唯一的区别就是返回的是AbstractCollection的子类， 

 * 主要是因为value不需要保持互异性。 

public Collection V values() { 

 Collection V vals = values; 

 if (vals == null) { 

 vals = 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); 

 values = vals; 

 return vals; 

}

它还提供了两个Entry的实现类：SimpleEntry与SimpleImmutableEntry，这两个类的实现非常简单，区别也只是前者是可变的，而后者是不可变的。

private static boolean eq(Object o1, Object o2) { 

 return o1 == null ? o2 == null : o1.equals(o2); 

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 ?,? 

 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的区别在于它是不可变的，value被final修饰，并且不支持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; 

 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 ?,? 

 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; 

}

我们通过阅读上述的源码不难发现，AbstractMap实现的操作都依赖于entrySet()所返回的集合视图。剩下的函数就没什么好说的了，有兴趣的话可以自己去看看。

15085.html