Java - 关于HashMap通过keySet遍历kv的二次调用问题

• 一. HashMap的常规遍历
• 二. keySet的二次遍历问题
• • 2.1 foreach和迭代器
  • 2.2 问题分析
  • 2.3 总结
• 三. entrySet()遍历key和value的优势

一. 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()。