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
    
      implements Map
     
       {
        transient Set
      
               keySet;    transient Collection
       
         values;    protected AbstractMap() {
        }    public int size() {
            return entrySet().size();    }    public boolean isEmpty() {
            return size() == 0;    }
       
      
     
    

以上几个方法的实现都比较简单，需要注意的是，entrySet()方法在这个抽象类中并没有实现。

public boolean containsValue(Object value) {
            Iterator
    
     
      > i = entrySet().iterator();        if (value==null) {
                while (i.hasNext()) {
                    Entry
      
        e = i.next();                if (e.getValue()==null)                    return true;            }        } else {
                while (i.hasNext()) {
                    Entry
       
         e = i.next();                if (value.equals(e.getValue()))                    return true;            }        }        return false;    }    public boolean containsKey(Object key) {
            Iterator
        
         
          > i = entrySet().iterator(); if (key==null) { while (i.hasNext()) { Entry
          
            e = i.next(); if (e.getKey()==null) return true; } } else { while (i.hasNext()) { Entry
           
             e = i.next(); if (key.equals(e.getKey())) return true; } } return false; }
           
          
         
        
       
      
     
    

以上两个分别判断是否包含键与值的方法，都是依赖迭代器来实现，实现方法比较安全，但是这种依赖遍历的方式效率是比较低的。

public V get(Object key) {
            Iterator
    
     
      > i = entrySet().iterator();        if (key==null) {
                while (i.hasNext()) {
                    Entry
      
        e = i.next();                if (e.getKey()==null)                    return e.getValue();            }        } else {
                while (i.hasNext()) {
                    Entry
       
         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
        
         
          > i = entrySet().iterator(); Entry
          
            correctEntry = null; if (key==null) { while (correctEntry==null && i.hasNext()) { Entry
           
             e = i.next(); if (e.getKey()==null) correctEntry = e; } } else { while (correctEntry==null && i.hasNext()) { Entry
            
              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
     m) {
            for (Map.Entry
     e : m.entrySet())            put(e.getKey(), e.getValue());    }    public void clear() {
            entrySet().clear();    }    public Set
    
      keySet() {
            Set
     
       ks = keySet;        if (ks == null) {
                ks = new AbstractSet
      
       () {
                    public Iterator
       
         iterator() {
                        return new Iterator
        
         () {
                            private Iterator
         
          
           > 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
           
             values() { Collection
            
              vals = values; if (vals == null) { vals = new AbstractCollection
             
              () { public Iterator
              
                iterator() { return new Iterator
               
                () { private Iterator
                
                 
                  > 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
                  
                   
                    > 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
    
     
      > i = entrySet().iterator();            while (i.hasNext()) {
                    Entry
      
        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
    
     
      > i = entrySet().iterator();        while (i.hasNext())            h += i.next().hashCode();        return h;    }    public String toString() {
            Iterator
      
       
        > i = entrySet().iterator();        if (! i.hasNext())            return "{}";        StringBuilder sb = new StringBuilder();        sb.append('{');        for (;;) {
                Entry
        
          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类了。