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;
}
}
时间： 2024-10-13 09:08:18