AbstractMap类是Map接口的子类，实现了Map接口大部分方法，它的子类只需要实现Set<Entry<K,V>> entrySet() 返回一个键值对的集合，就可以使用Map集合的功能了。
一.AbstractMap抽样类
1.1 添加方法
public V put(K key, V value) {
throw new UnsupportedOperationException();
}
直接抛出异常，如果子类不复写这个方法，那么它是一个不可修改的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());
}
遍历Map集合m，通过它的entrySet()方法得到可迭代的Set集合，然后将每个键值对存放到本Map集合中。
1.2 删除方法
public V remove(Object key) {
// 得到键值对的迭代器
Iterator<Entry<K,V>> i = entrySet().iterator();
Entry<K,V> correctEntry = null;
// 根据key是否为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;
// 如果找这个键值对correctEntry，删除它，并返回它的value值
if (correctEntry !=null) {
oldValue = correctEntry.getValue();
i.remove();
}
return oldValue;
}
通过entrySet().iterator()方法，得到键值对的迭代器，然后遍历键值对，找到与key值相等的键值对，删除它，并返回对应的value值，如果没找到，就返回null。
public void clear() {
entrySet().clear();
}
调用entrySet集合的clear()方法。
1.3 查找元素
public boolean containsKey(Object key) {
// 得到键值对的迭代器
Iterator<Map.Entry<K,V>> i = entrySet().iterator();
// 根据key是否为null，分成两部分
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().iterator()方法，得到键值对的迭代器，然后遍历键值对，找到与key值相等的键值对，返回true，否则返回false。
public boolean containsValue(Object value) {
// 得到键值对的迭代器
Iterator<Entry<K,V>> i = entrySet().iterator();
// 根据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;
}
通过entrySet().iterator()方法，得到键值对的迭代器，然后遍历键值对，找到与value值相等的键值对，返回true，否则返回false。
public V get(Object key) {
// 得到键值对的迭代器
Iterator<Entry<K,V>> i = entrySet().iterator();
// 根据key是否为null，分成两部分，
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().iterator()方法，得到键值对的迭代器，然后遍历键值对，找到与key值相等的键值对，并返回对应的value值，如果没找到，就返回null。
1.4 遍历Map集合。
我们知道Map接口可以返回三个集合，分别是key值组成的Set<K>集合，value值组成的Collection<V>集合，以及键值对组成的Set<Map.Entry<K, V>>集合。
其实这里面最重要的是键值对组成的Set集合，因为其他两个集合是可以通过这个集合得到。
public Set<K> keySet() {
// 使用keySet变量做缓存用的，这样只有第一次时需要遍历entrySet()集合。
Set<K> ks = keySet;
if (ks == null) {
// 创建一个Set集合，对它的操作都调用Map集合对应方法。
ks = new AbstractSet<K>() {
public Iterator<K> iterator() {
// 创建一个迭代器，利用 entrySet().iterator()的迭代器来实现本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;
}
public Collection<V> values() {
// 使用values变量做缓存用的，防止每次都遍历创建
Collection<V> vals = values;
if (vals == null) {
// 创建一个Collection集合，对它的操作都调用Map集合对应方法。
vals = new AbstractCollection<V>() {
public Iterator<V> iterator() {
// 创建一个迭代器，利用 entrySet().iterator()的迭代器来实现本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;
}
AbstractMap的内部类 SimpleEntry
SimpleEntry实现了Map.Entry接口，表示一个简单地键值对类。它有两个成员属性key、value来存储键值对。
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;
// 构造函数时，就传入key值和value值
public SimpleEntry(K key, V value) {
this.key = key;
this.value = value;
}
// 或者使用另一个entry来初始化key值和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;
}
// 替换value值，并返回原来的oldValue值
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
// 当key值与value值都相等时，就说明两个entry值相等
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());
}
// 保证两个相等的entry，它们的hashCode值必须也相同
public int hashCode() {
return (key == null ? 0 : key.hashCode()) ^
(value == null ? 0 : value.hashCode());
}
public String toString() {
return key + "=" + value;
}
}
AbstractMap的内部类 SimpleImmutableEntry
SimpleImmutableEntry表示一个不可修改键值对Entry类，也就是说它的setValue(V value)方法会直接抛出异常，其他方法与SimpleEntry类一样。
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;
// 构造函数时，就传入key值和value值
public SimpleImmutableEntry(K key, V value) {
this.key = key;
this.value = value;
}
// 当key值与value值都相等时，就说明两个entry值相等
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类，所以setValue方法直接抛出异常
public V setValue(V value) {
throw new UnsupportedOperationException();
}
// 当key值与value值都相等时，就说明两个entry值相等
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());
}
// 保证两个相等的entry，它们的hashCode值必须也相同
public int hashCode() {
return (key == null ? 0 : key.hashCode()) ^
(value == null ? 0 : value.hashCode());
}
public String toString() {
return key + "=" + value;
}
}
总结
AbstractMap抽样类
- 强制子类复写Set<Entry<K,V>> entrySet()方法。
- V put(K key, V value)：直接抛出异常，如果不复写这个方法，那么集合是不能添加数据的。
- void putAll(Map<? extends K, ? extends V> m)：是遍历集合，然后调用put方法，将元素添加到集合中，所以也会抛出异常。
- V remove(Object key)：调用entrySet集合迭代器的remove()实现的，并返回移除的value值。
- void clear()：调用entrySet集合迭代器的clear()方法实现的。
- boolean containsKey(Object key)：通过entrySet集合迭代器来遍历Map集合，查找key值相同元素。
- containsValue(Object value)：通过entrySet集合迭代器来遍历Map集合，查找value值相同元素。
- V get(Object key)：通过entrySet集合迭代器来遍历Map集合，查找key值相同键值对元素，并返回value值。如果没找到就返回null。
- Set<K> keySet()：创建一个Set集合，实现都是调用entrySet集合对应方法。
10.Collection<V> values()：创建一个Collection集合，实现都是调用entrySet集合对应方法。
AbstractMap的内部类 SimpleEntry和SimpleImmutableEntry
都是实现了Map.Entry接口，表示一个简单地键值对类。它有两个成员属性key、value来存储键值对。
唯一不同的是SimpleImmutableEntry表示一个不可修改键值对Entry类，，也就是说它的setValue(V value)方法会直接抛出异常。
