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