HashMap的遍历

查看Map接口，我们发现Map提供三种collection视图：

键集 Set<> keySet()：返回此映射中包含的键的 Set 视图。该 set 受映射支持，所以对映射的更改可在此 set 中反映出来，反之亦然。如果对该 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。set 支持元素移除，通过 Iterator.remove、 Set.remove、 removeAll、 retainAll 和 clear 操作可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

值集Collection<> values()：返回此映射中包含的值的 Collection 视图。该 collection 受映射支持，所以对映射的更改可在此 collection 中反映出来，反之亦然。如果对该 collection 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。collection 支持元素移除，通过 Iterator.remove、 Collection.remove、 removeAll、 retainAll 和 clear 操作可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

键-值映射关系集Set<> keySet()：返回此映射中包含的键的 Set 视图。该 set 受映射支持，所以对映射的更改可在此 set 中反映出来，反之亦然。如果对该 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。set 支持元素移除，通过 Iterator.remove、 Set.remove、 removeAll、 retainAll 和 clear 操作可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

1 HashMap的迭代器

在java中一提到 util 中的遍历，首先应该想到的就是它的迭代器，其他方法的迭代往往要么性能比迭代器低，要么本质上还是调用的迭代器。所以，我们先来分析一下HashMap的迭代器。

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
//table就是一个哈希表中的【桶】，可以简单理解为一个数组
Entry[] t = table;
//从第一个【桶】开始查找，找到第一个不为空的桶，使index等于这个桶的下标，next指向这个桶作为初始值
while (index < t.length && (next = t[index++]) == null)
;
}
}

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

final Entry<K,V> nextEntry() {
//fast-fail，非同步的机制，如果不明白暂时忽略
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();

//这个地方很重要。首先，next = e.next 访问的是Entry链，如果next不为空，则返回next了；如果next为空，则像初始化的时候那样，利用index找到下一个不为空的桶。
if ((next = e.next) == null) {
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}

//这里的current到没有什么特殊的，iterator中的基本机制，维护一个current entry，用于迭代器的remove
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;
}
}

但是看到这里，我们就会去找HashMap中的public iterator() 方法啊，只有实现了这个方法才能使用HashMap的迭代器啊，可是，我们没有找到！HashMap没有迭代器！？当然不是。准确来说，HashMap有多个迭代器！

（1）ValueIterator

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

（2）KeyIterator

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

（3）EntryIterator

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

这三个迭代器正好对应了前面提到的HashMap的三个视图。不难发现，它们三个迭代器其实都是在调用HashIterator的代码得到一个entry，知不是三个迭代器分别返回K，V，K-V对而已。【所以，这三个迭代器的性能是一样的。】

2 视图方法

2.1 entrySet()

public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}

private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}

private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
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();
}
}

从上面的代码不难看出，EntrySet几乎只是一个Set的最小实现。Set类不像Map类有get方法，Set中保存的数据的读取主要考迭代器。所以，这里的Set视图并不是在内存中开辟出新的位置，再把数据复制过来，而是返回一个精心设计的迭代器而已。所以，又不得不佩服编写Java文档的人的高智商。这里的【视图】一词用的是极好的，学过数据库基础的人应该都了解这个概念。

顺便提一下的是，这个Set视图中，数据的唯一性并不是它本身在维护，而是HashMap在构建的时候，要求key唯一维护起来的。

其实，分析过Set接口和它的几个实现类（比如HashSet）之后，不能发现，Set接口本来就不具备保证唯一性的能力，它更像是Java的一种规定。

然后ketSet() 和entrySet() 类似，都是返回一个set视图，所以我在这里就不赘述了。

2.2 values()

values() 跟上面提到的两个不一样的地方是，HashMap中，值是可能相等的，所以，它返回的不是Set，而是Collection。当然，其实也没有太大差别，依然只用用迭代器访问。就像前面分析的一样，这里的Set和Collection的展示意义大于实际意义，为的是规定上的一致性。

3 运用实例

（1）for each map.entrySet()

Map<String, String> map = new HashMap<String, String>();
for (Entry<String, String> entry : map.entrySet()) {
entry.getKey();
entry.getValue();
}

（2）显示调用map.entrySet()的集合迭代器

Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
entry.getKey();
entry.getValue();
}

上面这两种遍历方法是推荐的。至于利用foreach或者显示调用迭代器获取键集或值集我就不啰嗦了，一样的，性能也一样。

（3）用临时变量保存map.entrySet()

Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
entry.getKey();
entry.getValue();
}

跟（1）几乎一模一样，没什么问题，就是有点low。因为对于Set<>的变量，你实际上什么操作也不能做，何必多打字呢。

（4）for each map.keySet()，再调用get获取

Map<String, String> map = new HashMap<String, String>();
for (String key : map.keySet()) {
map.get(key);
}

这属于花样作死。用key去get value，每get一次就是遍历哈希表一次，效率太低了。还是那句话，如果可以用迭代器，绝对用迭代器效率最高。