Java - 关于HashMap通过keySet遍历kv的二次调用问题
一. HashMap的常规遍历
HashMap有四种遍历：
-
keySet()：遍历Map里面的Key。 -
values()：遍历Map里面的Value。 -
entrySet()：能够同时遍历Map里面的Key和Value。 -
foreach：可以直接访问key和value。（JDK8）
Demo如下：
@Test
public void testHashMap() {
HashMap<Integer, String> map = new HashMap<Integer, String>() {{
put(1, "value1");
put(2, "value2");
put(3, "value3");
}};
System.out.println("--------------打印Key--------------");
for (Integer integer : map.keySet()) {
System.out.println(integer);
}
System.out.println("--------------打印Value--------------");
for (String value : map.values()) {
System.out.println(value);
}
System.out.println("--------------打印key+value--------------");
for (Map.Entry<Integer, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + "----" + entry.getValue());
}
System.out.println("--------------foreach形式打印--------------");
map.forEach((key, value) -> {
System.out.println(key + "----" + value);
});
}
结果如下：
本文着重要讲一下keySet的二次遍历问题。
二. keySet的二次遍历问题
在说keySet()的二次遍历问题之前，需要声明二次遍历问题的讨论前提是：
用keySet()来进行Map遍历，来访问Key+Value。 一次遍历不能同时获取key和value。
2.1 foreach和迭代器
接下来再讲一下迭代器的相关知识，先看下上面的部分代码：
@Test
public void testHashMap() {
HashMap<Integer, String> map = new HashMap<Integer, String>() {{
put(1, "value1");
put(2, "value2");
put(3, "value3");
}};
System.out.println("--------------打印Key+Value--------------");
for (Integer key: map.keySet()) {
System.out.println(key + "----" + map.get(key));
}
}
我们要知道，上述代码中的for循环其实是foreach的写法，如果希望能够使用foreach循环，必须实现Iterable接口。以下两种写法是等价的：
for(T type: collections){
// 操作
}
以及
Iterator i = collections.iterator();
while(i.hasNext()){
T type = i.next();
// 操作
}
那么首先我们来验证下keySet()为何能使用foreach的写法（本质迭代器），来看下这个方法的源码：
public Set<K> keySet() {
// 第一次进来肯定是null
Set<K> ks = keySet;
if (ks == null) {
// 进行初始化
ks = new KeySet();
keySet = ks;
}
return ks;
}
那么我们来看下KeySet这个内部类的继承关系：
很不错，确实实现了Iterable接口，那么在遍历的过程中，本质上也确实用了迭代器，那么为了方便本文对于二次遍历问题的讨论，我们将上述写法改为：（等价代码）
@Test
public void testHashMap() {
HashMap<Integer, String> map = new HashMap<Integer, String>() {{
put(1, "value1");
put(2, "value2");
put(3, "value3");
}};
Iterator<Integer> i = map.keySet().iterator();
while (i.hasNext()) {
Integer key = i.next();
System.out.println(key + "----" + map.get(key));
}
}
2.2 问题分析
首先，我们先从代码的宏观角度（也就是表面上来看）来讨论，上述代码就有两次循环：
第一次：Iterator<Integer> i = map.keySet().iterator();，循环遍历Map，将key加入到迭代器。
第二次：while (i.hasNext()) ：目的是循环遍历key，通过key来从map中获取value。
那么对于第二次遍历，相比大家也不用多看和多问吧，while循环了都，不是遍历是什么？那么这里就对iterator()方法作出简要的分析：
还记得上文中，ks = new KeySet();初始化的这行代码吗？来看下这个KeySet：
final class KeySet extends AbstractSet<K> {
public final int size() { return size; }
public final void clear() { HashMap.this.clear(); }
public final Iterator<K> iterator() { return new KeyIterator(); }
public final boolean contains(Object o) { return containsKey(o); }
public final boolean remove(Object key) {
return removeNode(hash(key), key, null, false, true) != null;
}
public final Spliterator<K> spliterator() {
return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer<? super K> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.key);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
由于子类如果重写了父类的方法，那么最终实现会走子类，因此我们来看下KeySet.iterator()方法：
final class KeyIterator extends HashIterator
implements Iterator<K> {
public final K next() { return nextNode().key; }
}
↓↓↓↓↓nextNode()↓↓↓↓↓↓
final Node<K,V> nextNode() {
// ...省略
if ((next = (current = e).next) == null && (t = table) != null) {
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
可以发现这个do/while循环，来看下Debug过程：可见确实走了循环（具体什么操作就不说了）
2.3 总结
在通过keySet()方式来遍历获得Map里面的key和value的情况下，会进行二次遍历。
三. entrySet()遍历key和value的优势
首先来看下代码：
@Test
public void testHashMap() {
HashMap<Integer, String> map = new HashMap<Integer, String>() {{
put(1, "value1");
put(2, "value2");
put(3, "value3");
}};
Iterator<Map.Entry<Integer, String>> i = map.entrySet().iterator();
while (i.hasNext()) {
Map.Entry<Integer, String> entry = i.next();
System.out.println(entry.getKey() + "----" + entry.getValue());
}
}
我们可以发现，迭代器里面的对象，是个Entry<Integer, String>，可以直接通过entry.getKey()和entry.getValue()拿到对象（记住，这里指的是第一次遍历的时候，就能够同时将key和value存放于迭代器中）
为了避免大家的误解，在这里做一次重申，假设我们只考虑生成迭代器的步骤。
-
keySet()方式：Iterator<Integer> i = map.keySet().iterator();这里只能拿到key，value得再做一次遍历来取。 -
entrySet()方式：Iterator<Map.Entry<Integer, String>> i = map.entrySet().iterator();可同时拿到key和value。
最后，希望大家在后续开发过程中，遇到遍历来对key和value同时做处理的，一定要用entrySet()来遍历，不要用keySet()。