从源码分析：Java中的Map（一）Map接口与AbstractMap抽象类
HashMap的继承结构
Java中，我们最常用的map类型可能就是HashMap了，这一次介绍的重点也在HashMap上面。但是，在我们详细分析HashMap之前，我们先来看一下HashMap的继承结构：
Java中的Map接口
从上面的继承结构中，可以看出，Java中的HashMap是接口Map的一个实现类，因此，在我们分析HashMap之前，不妨先来看看Map接口。
首先，我们来看一下Map中定义的方法：
可以看到，我们常用的方法，如get、set、size、isEmpty、remove、keySet、entrySet等，在map接口中都有定义，因此我们无论使用map接口的哪个具体实现类，都可以使用这个方法。
同时，注意到Map接口中还有着一个内部类的接口Entry，那么我们再来看看这个内部类的接口中定义了哪些方法吧
从Entry的接口方法中可以看到，我们对于Entry的常用的方法，在这里也都有定义。
AbstractMap类
除了实现了Map的接口外，Java中的Map的具体类多数还继承了一个叫做AbstractMap的抽象类，这个抽象类是Java中为了实现Map所写的一个便利类，其中已经实现了很多Map所需的方法，也就是说如果我们需要其它的一个具体类，只需要完成抽象类AbstractMap中所没有实现的方法即可（当然，也可以重写已实现的方法来实现具体的功能）。
我们先来看一下AbstractMap中实现的方法：
这些方法都是已经有具体实现的方法，这里把其中一些常见的方法的实现贴出来：
public abstract class AbstractMap<K,V> implements Map<K,V> {
transient Set<K> keySet;
transient Collection<V> values;
protected AbstractMap() {
}
public int size() {
return entrySet().size();
}
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;
}
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;
}
以上两个分别判断是否包含键与值的方法，都是依赖迭代器来实现，实现方法比较安全，但是这种依赖遍历的方式效率是比较低的。
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();
}
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;
}
以上三个为get、put、remove方法，get函数与上面的两个判断函数相同，都是依赖通过迭代器来遍历的方式实现的，安全但是效率较低。接下来的put方法并没有进行实现，如果调用到了这个方法（如其具体实现类也没有实现这个方法），会抛出一个异常。最后，remove的实现与get相同，先通过迭代器的遍历找到要删除的键所对应的值，最后依赖迭代器的remove来实现删除，并将刚刚找到的值返回。
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();
}
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;
}
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;
}
public abstract Set<Entry<K,V>> entrySet();
这里，putAll是依赖这个抽象类里并没有实现的put方法来实现，clear是依赖同样没有实现的entrySet方法来实现，接下来的ketSet与values方法都是通过新建一个扩展了抽象类（AbstractSet与AbstractCollection）的类的对象，之后将属性输入到属性，再返回这个对象的方法来实现的。最后一个，entrySet方法，emmmm，前面有很多方法都是依赖这个方法的返回值来进行的，但是这个方法再这个抽象类里是没有被实现的。
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<?,?> m = (Map<?,?>) o;
if (m.size() != size())
return false;
try {
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
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;
}
一个重头戏，equals方法，这个方法在HashMap中也是需要重点关注的方法，这里，我们先看一下AbstractMap中的判断相等的方法是怎样写的吧。
首先，对于输入的对象o，判断其地址与当前对象（this）是否相同，若是，则返回true，否则继续判断，是否为Map接口的实现类的对象，若是则继续，将其类型强制转换为Map类型，然后比较两者的size是否一致。通过以上几个非常快的判断，已经可以以很高的效率，将大部分的不相等的对象返回正确的false的结果了。
在以上判断全都通过的情况下，接下来，和前面的很多方法一样，接下来，会通过引入entrySet来进行判断（嗯，就是通过前面所说的还没有实现的entrySet()方法来得到所需的entrySet），在得到entrySet后，通过entrySet的迭代器来得到每个entry的键和值，先判断o中是否包含这个键，若包含，则通过这个键得到o中所对应的值，判断entry中的值与这个值是否相等，若相等，则继续通过迭代器得到下一个值，继续判断，若不相等，则返回false。若遍历完所有的元素，没有不一样的元素，则返回true，说明两个map完全相同。
public int hashCode() {
int h = 0;
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext())
h += i.next().hashCode();
return h;
}
public String toString() {
Iterator<Entry<K,V>> i = entrySet().iterator();
if (! i.hasNext())
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(' ');
}
}
protected Object clone() throws CloneNotSupportedException {
AbstractMap<?,?> result = (AbstractMap<?,?>)super.clone();
result.keySet = null;
result.values = null;
return result;
}
最后，就是我们很多自己写的类也会实现的一些方法了，如’toString()'方法，描述了应该怎样输出这个map，clone则会调用Object中的clone方法，实则需要实现类来实现。而hashCode()方法，则是一次得到每一个entry的hashcode`，再将其全部加起来作为自己的hashcode。
总结
至此，我们便将HashMap所实现的Map接口，与所继承的AbstractMap抽象类都详细地看过了，以这些为基础，接下来，我们就可以来看我们所需重点关注的HashMap类了。
