随笔2 AbstractMap<K,V>

上一篇写了Map接口的源码分析，这一篇写一下Map接口的一个实现类AbstractMap，从名字就可以看出这是一个抽象类，提供了Map接口的骨架实现，为我们实现Map接口的时候提供了很大的便利。在这里类中，还有一个抽象方法entrySet没有被实现，在实现的方法中put方法也仅仅抛出了一个异常。我们在继承这个类写自己的Map时，如果是一个不支持赋值的Map，那么只需要实现entrySet方法。如果是实现一个可以添加键值对的Map，那么不仅要实现entrySet方法，还需要在entrySet返回的那个迭代器中的remove方法。

本篇会参考http://blog.csdn.net/Airsaid/article/details/51178444写的分析的组织方式，并最后简单的实现一个Map作为实例

源码分析

构造方法

 protected AbstractMap() {
 }

在Map的建议中，是希望有两个构造函数，一个是无参构造函数，另一个是以Map为参数的构造函数，但此处只实现了一个无参构造函数，给子类提供了一个构造方法

成员变量

 transient Set<K>        keySet;
 transient Collection<V> values;

这两个成员将分别保存Map当中的键和值，因为Map要保证键的唯一性，所以在保存键的时候使用了Set<K>这种数据结构，而Map中的值是可以重复的，所以要使用Collection<V>这种数据结构来存储。在这里还要说一下transient关键字，由于AbstractMap的子类HashMap等都实现了Serializable接口，但是在序列化的时候，AbstractMap不希望暴露底层的数据集，所以添加transient，让这两个成员变量不被序列化。我看到有些源码分析说这两个变量被volatile关键字修饰，目的是保证一定的线程安全，但是我在jdk1.8中并没有看到。

抽象方法

 public abstract Set<Entry<K,V>> entrySet();

个人感觉这个地方写的很精髓，这个类中的大部分实现的方法会调用这个方法，而这个方法将底层数据结构的实现方式交给了他的派生类，确实把AbstractMap抽象到了一个很高的高度，极大的降低了和底层的耦合度。而且由于Set的实现方式不同，导致导出的迭代器也不一样，感觉这里特别值得学习。

实例方法

查询方法

     public int size() {
         return entrySet().size();
     }

此方法返回集合长度

     public boolean isEmpty() {
         return size() == 0;
     }

判断Map是否为空

     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;
     }

查询Map中是否存在目标值，这里允许保存null

     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;
     }

这里同上，只不过是查询key的值

     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;
     }

通过key查询value，当value存在时返回value，否则返回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;
     }

当指定的key存在时，会删除对应的键值对，返回对应的值，如果不存在，则返回null。这里要注意的是需要子类重写迭代器的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());
     }

将指定的Map中的元素放入本Map中，这里要注意如果没有实现put方法会报出异常

     public void clear() {
         entrySet().clear();
     }

清空Map

视图

返回所有key的set集合：

     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;
     }

这里可以看到是使用了匿名内部类的方法 ，通过AbstractSet来返回了一个Set，而AbstractSet这个抽象类中看似都实现了方法，但是在他的父类AbstractCollection和他实现的接口Set中，都有未实现的方法iterator()和size()两个抽象方法，所以这两个方法是必须实现的，而在iterator()这个方法中又使用匿名内部类的方式通过接口Iterator来生成一个迭代器，这个接口只有两个方法需要实现hasNext()和next()这两个方法，但是在Iterator中remove()方法只是抛出了一个不支持方法的异常，所以这里仍然需要重写。

返回所有value的collection集合

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;
    }

这个方法和上一个很类似，唯一不同的是第一次使用匿名内部类的时候用的是AbstractCollection，但由于AbstractSet的父类就是AbstractCollection，所以本质并没有什么区别

比较和散列

比较指定的对象与当前Map是否相等，代码很好懂，就不做过多的解释了。

     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;
     }

返回当前Map的hashcode，对每一个Entry对象都需要计算

     public int hashCode() {
         int h = 0;
         Iterator<Entry<K,V>> i = entrySet().iterator();
         while (i.hasNext())
             h += i.next().hashCode();
         return h;
     }

其他方法

覆盖Object的toString()方法，这里注意编程细节，这里使用了StringBuilder，这种可以追加字符串的类，这里应该是为了效率而放弃了线程安全，没有使用StringBuffer

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

覆盖Object的clone()实现浅拷贝

     protected Object clone() throws CloneNotSupportedException {
         AbstractMap<?,?> result = (AbstractMap<?,?>)super.clone();
         result.keySet = null;
         result.values = null;
         return result;
     }

私有静态方法，用来判断两个对象是否相等，这是给接下来两个静态内部类使用的

     private static boolean eq(Object o1, Object o2) {
         return o1 == null ? o2 == null : o1.equals(o2);
     }

接下来这两个类都是Map.Entry<K,V>的实现类，一个是可以修改值的，一个是不可修改值的，从命名就可以看出，是给同学们自己实现Map接口的时候，打个样怎么样去实现一个Entry接口，由于这两个类都是静态公有内部类，其访问方式和普通的public类没什么区别，不需要依附于外部类AbstractMap的实例中，并且只能访问AbstractMap的静态区域

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;

         /**
          * Creates an entry representing a mapping from the specified
          * key to the specified value.
          *
          * @param key the key represented by this entry
          * @param value the value represented by this entry
          */
         public SimpleEntry(K key, V value) {
             this.key   = key;
             this.value = value;
         }

         /**
          * Creates an entry representing the same mapping as the
          * specified entry.
          *
          * @param entry the entry to copy
          */
         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<?,?>)o;
             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;
         }

     }

这里我么你来关注一下hashCode()方法，这里是用key和value做与操作，头一次看见，感觉很特别

SimpleImmutableEntry

     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<?,?>)o;
             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;
         }

     }

不同之处在于setValue方法，直接抛出不支持异常

实现一个可以赋值的Map

这个Map实现的很简单，赋值十次以后就错了呦，没有增加扩展功能，喜欢的同学可以自己加一个试试

 public class CanPutMap<K,V> extends AbstractMap<K,V> implements Map<K,V> {

     private Node<K,V> table[];

     private int index;

     private Set<Entry<K,V>> entrySet;

     public CanPutMap() {
         table = (Node<K,V>[])new Node[];
         index = ;
     }

     public V put(K key, V value) {
         V oldValue = null;
         for(int i = ; i < table.length; i++) {
             if(table[i] != null && table[i].getKey() == key) {
                 oldValue = table[i].getValue();
                 table[i].setValue(value);
                 break;
             }
         }
         if(oldValue == null) {
             table[index++] = new Node<K,V>(key, value);
         }
         return oldValue;
     }

     public V get(Object key) {
         V value = null;
         for(int i = ; i < table.length; i++) {
             if(table[i] != null && table[i].getKey() == key) {
                 value = table[i].getValue();
                 break;
             }
         }
         return value;
     }

     @Override
     public Set<Entry<K,V>> entrySet() {
         // TODO Auto-generated method stub
         Set<Entry<K,V>> es;
         return (es = entrySet) == null ? entrySet = new MySet(): es;
     }

     final class MySet extends AbstractSet<Entry<K,V>> {

         @Override
         public Iterator<java.util.Map.Entry<K, V>> iterator() {
             // TODO Auto-generated method stub
             return new MyIterator();
         }

         @Override
         public int size() {
             // TODO Auto-generated method stub
             return ;
         }

     }

     final class MyIterator implements Iterator<Entry<K,V>> {

         Node<K,V> current;

         Node<K,V> next;

         int index;

         public MyIterator() {
             Node<K,V>[] t = table;
             current = next = null;
             index = ;
             if(t != null && table.length > ) {
                 do{}while(index < table.length && (next = table[index++]) == null);
             }
         }

         @Override
         public boolean hasNext() {
             // TODO Auto-generated method stub
             return next != null;
         }

         @Override
         public java.util.Map.Entry<K, V> next() {
             // TODO Auto-generated method stub
             Node<K,V> e = next;
             current = next;
             do{}while(index < table.length && (next = table[index++]) == null);
             return e;
         }

         public final void remove() {
             for(int i = ; i < table.length; i++) {
                 if(table[i] == current) {
                     table[i] = null;
                 }
             }
         }

     }

     public static class Node<K,V> implements Entry<K,V> {

         private final K key;
         private V value;

         public Node(K key, V value) {
             this.key = key;
             this.value = value;
         }

         @Override
         public K getKey() {
             // TODO Auto-generated method stub
             return key;
         }

         @Override
         public V getValue() {
             // TODO Auto-generated method stub
             return value;
         }

         @Override
         public V setValue(V value) {
             // TODO Auto-generated method stub
             V oldValue = this.value;
             this.value = value;
             return oldValue;
         }

     }

     public static void main(String[] args) {
         Map<String, Integer> map = new CanPutMap<String, Integer>();
         map.put("", );
         map.put("", );
         map.put("", );
         for(Entry<String, Integer> e : map.entrySet()) {
             System.out.println(e.getKey() + "->" + e.getValue());
         }
         for(Iterator<Entry<String, Integer>> i = map.entrySet().iterator(); i.hasNext();) {
             Entry<String, Integer> e = i.next();
             System.out.println(e.getKey() + "->" + e.getValue());
             if(e.getKey().equals("")) {
                 i.remove();
             }
         }
         for(Entry<String, Integer> e : map.entrySet()) {
             System.out.println(e.getKey() + "->" + e.getValue());
         }
     }

 }