关于HashMap的遍历输出，以及以遍历形式删除键值对所出现的问题。

• 一 HashMap遍历输出的几种方式

1. 　foreach 取出map.entrySet()并获取key和value

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

    

2. 调用map.entrySet()的集合迭代器，通过hasNext()方法判断是否有元素可迭代

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

    

3. 通过HashMap中的keySet()方法获取key集合，通过循环获取value

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

    

4. 通过临时变量保存map.entrySet()，遍历输出

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

    

　　以上就是常用的四种遍历输出hashMap集合的方法，接下来分析一下四种方法的适用性和效率。

•  二 HashMap常用的四种遍历方法的分析对比及实用性

 　　　　先贴上代码(代码参考)

package com.lwu.java.test;
 
import java.text.DecimalFormat;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
 
/**
 * JavaLoopTest
 * 
 * @author www.trinea.cn 2013-10-28
    
 */
public class JavaLoopTest {
 
    public static void main(String[] args) {
        System.out.print("compare loop performance of HashMap");
        loopMapCompare(getHashMaps(10000, 100000, 1000000, 2000000));
    }
 
    public static Map<String, String>[] getHashMaps(int... sizeArray) {
        Map<String, String>[] mapArray = new HashMap[sizeArray.length];
        for (int i = 0; i < sizeArray.length; i++) {
            int size = sizeArray[i];
            Map<String, String> map = new HashMap<String, String>();
            for (int j = 0; j < size; j++) {
                String s = Integer.toString(j);
                map.put(s, s);
            }
            mapArray[i] = map;
        }
        return mapArray;
    }
 
    public static void loopMapCompare(Map<String, String>[] mapArray) {
        printHeader(mapArray);
        long startTime, endTime;
 
        // Type 1
        for (int i = 0; i < mapArray.length; i++) {
            Map<String, String> map = mapArray[i];
            startTime = Calendar.getInstance().getTimeInMillis();
            for (Entry<String, String> entry : map.entrySet()) {
                entry.getKey();
                entry.getValue();
            }
            endTime = Calendar.getInstance().getTimeInMillis();
            printCostTime(i, mapArray.length, "for each entrySet", endTime - startTime);
        }
 
        // Type 2
        for (int i = 0; i < mapArray.length; i++) {
            Map<String, String> map = mapArray[i];
            startTime = Calendar.getInstance().getTimeInMillis();
            Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, String> entry = iterator.next();
                entry.getKey();
                entry.getValue();
            }
            endTime = Calendar.getInstance().getTimeInMillis();
            printCostTime(i, mapArray.length, "for iterator entrySet", endTime - startTime);
        }
 
        // Type 3
        for (int i = 0; i < mapArray.length; i++) {
            Map<String, String> map = mapArray[i];
            startTime = Calendar.getInstance().getTimeInMillis();
            for (String key : map.keySet()) {
                map.get(key);
            }
            endTime = Calendar.getInstance().getTimeInMillis();
            printCostTime(i, mapArray.length, "for each keySet", endTime - startTime);
        }
 
        // Type 4
        for (int i = 0; i < mapArray.length; i++) {
            Map<String, String> map = mapArray[i];
            startTime = Calendar.getInstance().getTimeInMillis();
            Set<Entry<String, String>> entrySet = map.entrySet();
            for (Entry<String, String> entry : entrySet) {
                entry.getKey();
                entry.getValue();
            }
            endTime = Calendar.getInstance().getTimeInMillis();
            printCostTime(i, mapArray.length, "for entrySet=entrySet()", endTime - startTime);
        }
    }
 
    static int                 FIRST_COLUMN_LENGTH = 23, OTHER_COLUMN_LENGTH = 12, TOTAL_COLUMN_LENGTH = 71;
    static final DecimalFormat COMMA_FORMAT        = new DecimalFormat("#,###");
 
    public static void printHeader(Map... mapArray) {
        printRowDivider();
        for (int i = 0; i < mapArray.length; i++) {
            if (i == 0) {
                StringBuilder sb = new StringBuilder().append("map size");
                while (sb.length() < FIRST_COLUMN_LENGTH) {
                    sb.append(" ");
                }
                System.out.print(sb);
            }
 
            StringBuilder sb = new StringBuilder().append("| ").append(COMMA_FORMAT.format(mapArray[i].size()));
            while (sb.length() < OTHER_COLUMN_LENGTH) {
                sb.append(" ");
            }
            System.out.print(sb);
        }
        TOTAL_COLUMN_LENGTH = FIRST_COLUMN_LENGTH + OTHER_COLUMN_LENGTH * mapArray.length;
        printRowDivider();
    }
 
    public static void printRowDivider() {
        System.out.println();
        StringBuilder sb = new StringBuilder();
        while (sb.length() < TOTAL_COLUMN_LENGTH) {
            sb.append("-");
        }
        System.out.println(sb);
    }
 
    public static void printCostTime(int i, int size, String caseName, long costTime) {
        if (i == 0) {
            StringBuilder sb = new StringBuilder().append(caseName);
            while (sb.length() < FIRST_COLUMN_LENGTH) {
                sb.append(" ");
            }
            System.out.print(sb);
        }
 
        StringBuilder sb = new StringBuilder().append("| ").append(costTime).append(" ms");
        while (sb.length() < OTHER_COLUMN_LENGTH) {
            sb.append(" ");
        }
        System.out.print(sb);
 
        if (i == size - 1) {
            printRowDivider();
        }
    }
}

 

1. 测试结果(1,000,000条，3次) 

   　除了第三种遍历方式 通过HashMap中的keySet()方法获取key集合，通过循环获取value其余的三种遍历方式所耗时间差距不大。　

        2. 结果分析

　　　　由于其余三种遍历方式耗时差距不大，我们单独拿出与众不同的那一种遍历方式分析，揪出其源代码，找出造成耗时增长的原因。

　　　　相比于其余三种，通过HashMap中的keySet()方法获取key集合，通过循环获取value  （以下统称第三种方式）这种方法使用了keySet()这种方法，那么是不是这个元凶造成了遍历耗时增长呢？

 

　　　　老规矩，先贴源代码。

 1 //HashMap entrySet和keySet的源码
 2 private final class KeyIterator extends HashIterator<K> {
 3     public K next() {
 4         return nextEntry().getKey();
 5     }
 6 }
 7  
 8 private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
 9     public Map.Entry<K,V> next() {
10         return nextEntry();
11     }
12 }

　　　　　以上两种分别返回的是keySet() 和 entrySet()返回的set的迭代器。

　　　　　两种方法的区别只是返回值不同，父类相同。理论上讲两种方法的性能应该是相差无几的，在返回值上第三种方式多了一步getKey()的操作。 

　　　　　根据key获取value的时间复杂成都根据hash算法而产生差异，源码:

 1 public V get(Object key) {
 2     if (key == null)
 3         return getForNullKey();
 4     Entry<K,V> entry = getEntry(key);
 5  
 6     return null == entry ? null : entry.getValue();
 7 }
 8  
 9 /**
10  * Returns the entry associated with the specified key in the
11  * HashMap.  Returns null if the HashMap contains no mapping
12  * for the key.
13  */
14 final Entry<K,V> getEntry(Object key) {
15     int hash = (key == null) ? 0 : hash(key);
16     for (Entry<K,V> e = table[indexFor(hash, table.length)];
17          e != null;
18          e = e.next) {
19         Object k;
20         if (e.hash == hash &&
21             ((k = e.key) == key || (key != null && key.equals(k))))
22             return e;
23     }
24     return null;
25 }

　　　get的时间复杂程度取决于for循环的次数。

 

　　3.四种遍历方法的使用总结

　　　　　A:单从代码的角度出发:

　　　　　　如果只需要key值的而不需要value值的话可以使用:

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

　　　　　   B:从功能性和性能的角度出发:

　　　　　　　在同时需要key值和value值的前提下，无论是性能还是代码的简洁性来说，通过HashMap中的keySet()方法获取key集合，通过循环获取value  这种方法都是一个比较好的选择。

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

• 三 利用遍历的方式移除HashMap中的键值对

　　　　我们先来做一个猜想，是否可以通过前面的遍历方式来移除HashMap中的键值对？在上面的代码中加上

　　map.remove() ?

　　　　答案是不行的，在运行时会抛出以下异常 java.util.ConcurrentModificationException

at java.util.HashMap$HashIterator.nextNode(Unknown Source)
at java.util.HashMap$EntryIterator.next(Unknown Source)
at java.util.HashMap$EntryIterator.next(Unknown Source)

　　　　根据我从网上查询碰到同样情况的解决办法，他们个给出的是这样的解释:

　　　　由于我们在遍历HashMap的元素过程中删除了当前所在元素，下一个待访问的元素的指针也由此丢失了。

　　　　所以我们要换一种遍历方式，代码如下:

for (Iterator<Map.Entry<String, Integer>> it =myHashMap.entrySet().iterator(); it.hasNext();){
    Map.Entry<String, Integer> item = it.next();
    it.remove();
}
for (Map.Entry<String, Integer> item : myHashMap.entrySet()){
    System.out.println(item.getKey());
}

　　　　这种方法能满足大多数情况下的清除键值对的要求，那么对于特殊情况下我们应该怎么解决？

　　在HashMap的遍历中删除元素的特殊情况 

            这种情况是我在寻找别人碰到的类似的问题的时候发现的解决办法，所以在这里我就直接照搬了。 (转自@zhangnf 

Java HashMap 如何正确遍历并删除元素

侵删)

　　　 

　　　　如果你的HashMap中的键值同样是一个HashMap，假设你需要处理的是 HashMap<HashMap<String, Integer>, Double> myHashMap 时，很不碰巧，你可能需要修改myHashMap中的一个项的键值HashMap中的某些元素，之后再将其删除。

 

　　这时，单单依靠迭代器的 remove() 方法是不足以将该元素删除的。

 

　　例子如下：

HashMap<HashMap<String, Integer>, Integer> myHashMap = new HashMap<>();
HashMap<String, Integer> temp = new HashMap<>();
temp.put("1", 1);
temp.put("2", 2);
myHashMap.put(temp, 3);
for (Iterator<Map.Entry<HashMap<String, Integer>, Integer>> 
    it = myHashMap.entrySet().iterator(); it.hasNext();){
    Map.Entry<HashMap<String, Integer>, Integer> item = it.next();
    item.getKey().remove("1");
    System.out.println(myHashMap.size());
    it.remove();
    System.out.println(myHashMap.size());
}

　　结果如下：

1
1

　　

　　虽然 it.remove(); 被执行，但是并没有真正删除元素。

　　原因在于期望删除的元素的键值（即 HashMap<String, Integer> temp ）被修改过了。

---

       解决方案:

　　既然在这种情况下，HashMap中被修改过的元素不能被删除，那么不妨直接把待修改的元素直接删除，再将原本所需要的“修改过”的元素加入HashMap。

　　想法很好，代码如下：

for (Iterator<Map.Entry<HashMap<String, Integer>, Integer>> 
    it = myHashMap.entrySet().iterator(); it.hasNext();){
    Map.Entry<HashMap<String, Integer>, Integer> item = it.next();
    //item.getKey().remove("1");
    HashMap<String, Integer> to_put = new HashMap<>(item.getKey());
    to_put.remove("1");
    myHashMap.put(to_put, item.getValue());
    System.out.println(myHashMap.size());
    it.remove();
    System.out.println(myHashMap.size());
}

　　但是依然是RE：

Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.HashMap$HashIterator.remove(Unknown Source)

　　原因在于，迭代器遍历时，每一次调用 next() 函数，至多只能对容器修改一次。上面的代码则进行了两次修改：一次添加，一次删除。

---

 

　　

既然 java.util.ConcurrentModificationException 异常被抛出了，那么去想办法拿掉这个异常即可。

　　最后的最后，我决定弃HashMap转投ConcurrentHashMap。将myHashMap定义为ConcurrentHashMap之后，其它代码不动。

　　运行结果如下：

2
1