Map.Entry<K,V>分析

一。好处

你是否已经对每次从Map中取得关键字然后再取得相应的值感觉厌倦？

 Set keys = map.keySet( );
 if(keys != null) {
     Iterator iterator = keys.iterator( );
    while(iterator.hasNext( )) {
            Object key = iterator.next( );
            Object value = map.get(key);
      }
 } 

二。用法

使用Map.Entry类，你可以得到在同一时间得到所有的信息。标准的Map访问方法如下：

   for( Entry<Integer, Integer> e : mm.entrySet()){
       System.out.println("key:"+e.getKey() + "  value:"+e.getValue());

    }
    for( Iterator<Entry<Integer, Integer>> i = mm.entrySet().iterator();i.hasNext(); ){
       Entry<Integer, Integer> e = i.next();
       System.out.println("key:"+e.getKey() + "  value:"+e.getValue());

    }

三。分析

1.HashMap内部静态类Entry的成员变量和构造函数

     static class Entry<K,V> implements Map.Entry<K,V> {
         final K key;
         V value;
         Entry<K,V> next;
         final int hash;

         /**
          * Creates new entry.
          */
         Entry(int h, K k, V v, Entry<K,V> n) {
             value = v;
             next = n;
             key = k;
             hash = h;
         }

          。。。。。
      }

2.Iterator

     private final class ValueIterator extends HashIterator<V> {
         public V next() {
             return nextEntry().value;
         }
     }

     private final class KeyIterator extends HashIterator<K> {
         public K next() {
             return nextEntry().getKey();
         }
     }

     private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
         public Map.Entry<K,V> next() {
             return nextEntry();
         }
     }

3.HashIterator，注意快速报错机制实现

     private abstract class HashIterator<E> implements Iterator<E> {
         Entry<K,V> next;    // next entry to return
         int expectedModCount;    // For fast-fail
         int index;        // current slot
         Entry<K,V> current;    // current entry

         HashIterator() {
             expectedModCount = modCount;
             if (size > 0) { // advance to first entry
                 Entry[] t = table;
                 while (index < t.length && (next = t[index++]) == null)
                     ;
             }
         }

         public final boolean hasNext() {
             return next != null;
         }

         final Entry<K,V> nextEntry() {
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
             Entry<K,V> e = next;
             if (e == null)
                 throw new NoSuchElementException();

             if ((next = e.next) == null) {
                 Entry[] t = table;
                 while (index < t.length && (next = t[index++]) == null)
                     ;
             }
             current = e;
             return e;
         }

         public void remove() {
             if (current == null)
                 throw new IllegalStateException();
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
             Object k = current.key;
             current = null;
             HashMap.this.removeEntryForKey(k);
             expectedModCount = modCount;
         }

     }

3.EntrySet

     private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
         public Iterator<Map.Entry<K,V>> iterator() {
             return newEntryIterator();                                                 //创建EntryIterator
         }
         public boolean contains(Object o) {
             if (!(o instanceof Map.Entry))
                 return false;
             Map.Entry<K,V> e = (Map.Entry<K,V>) o;
             Entry<K,V> candidate = getEntry(e.getKey());
             return candidate != null && candidate.equals(e);
         }
         public boolean remove(Object o) {
             return removeMapping(o) != null;
         }
         public int size() {
             return size;
         }
         public void clear() {
             HashMap.this.clear();
         }
     }