[size=11.818181991577148px]这个是我以前学习的时候总结的一个帖子，贴出来看一下。

[size=11.818181991577148px]map的遍历有四种放肆，下面我对其分别罗列出来：

1. import java.util.HashMap;  
   
2. import java.util.Iterator;  
   
3. import java.util.Map;  
   
4.           
   
5. public class Test {  
   
6.           
   
7.     public static void main(String[] args) {  
   
8.                 Map<String, String> map = new HashMap<String, String>();  
   
9.                 map.put("aa", "aaa");  
   
10.                 map.put("bb", "bbb");  
    
11.                 map.put("cc", "ccc");  
    
12.           
    
13.   
    
14.         // 第一种：通过Map.keySet遍历key和value  
    
15.                 System.out.println("第一种方式：-------->通过Map.keySet遍历key和value:");  
    
16.                 for (String key : map.keySet()) {  
    
17.                                 System.out.println("key= " + key + "  and  value= " + map.get(key));  
    
18.                 }  
    
19.                   
    
20.              // 第二种：通过Map.entrySet使用iterator遍历key和value  
    
21.         System.out.println("第二种方式：-------->通过Map.entrySet使用iterator遍历key和value:");  
    
22.                 Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();  
    
23.                 while (it.hasNext()) {  
    
24.             Map.Entry<String, String> entry = it.next();  
    
25.           
    
26.                     System.out.println("key= " + entry.getKey() + "  and  value= "  
    
27.                             + entry.getValue());  
    
28.         }  
    
29.   
    
30.               // 第三种：通过Map.entrySet遍历key和value  
    
31.         System.out.println("第三种方式：-------->通过Map.entrySet遍历key和value:");  
    
32.                 for (Map.Entry<String, String> entry : map.entrySet()) {  
    
33.             System.out.println("key= " + entry.getKey() + "  and  value= "  
    
34.                     + entry.getValue());  
    
35.         }  
    
36.   
    
37.              // 第四种：通过Map.values()遍历所有的value，但是不能遍历键key  
    
38.        System.out.println("第四种方式：-------->通过Map.values()遍历所有的value:");  
    
39.                 for (String v : map.values()) {  
    
40.             System.out.println("value= " + v);  
    
41.                 }  
    
42.     }  
    
43.         }  

复制代码

[size=11.818181991577148px]结果如下：

1. 第一种方式：-------->通过Map.keySet遍历key和value:
   
2. key= aa  and  value= aaa
   
3. key= bb  and  value= bbb
   
4. key= cc  and  value= ccc
   
5. 第二种方式：-------->通过Map.entrySet使用iterator遍历key和value:
   
6. key= aa  and  value= aaa
   
7. key= bb  and  value= bbb
   
8. key= cc  and  value= ccc
   
9. 第三种方式：-------->通过Map.entrySet遍历key和value:
   
10. key= aa  and  value= aaa
    
11. key= bb  and  value= bbb
    
12. key= cc  and  value= ccc
    
13. 第四种方式：-------->通过Map.values()遍历所有的value:
    
14. value= aaa
    
15. value= bbb
    
16. value= ccc

复制代码

[size=11.818181991577148px]这四种方法都可以遍历map：

[size=11.818181991577148px]第一种是目前许多人最喜欢的一种方式，因为代码最少，看起来最简单，通过遍历keySet，再将key所对应的value查询出来，这里有一个二次取值的过程，所以并不推荐；

[size=11.818181991577148px]第二种和第三种原理是相同的，都是通过遍历Map.Entry的方式，将Entry中的key和value打印出来，第三种是比较推荐写法，因为采用jdk1.5后的遍历形式，代码看起来比较整洁；

[size=11.818181991577148px]第四种用的比较少了，因为我们大多数时候都是同时需要key和value的

[size=11.818181991577148px]综上所述，如果map里面内容比较少，其实采用哪种方式都可以，第一种和第三种相对简洁一些；但是一旦容量非常大时，更推荐采用第三种方式，相比于第一种将极大地节省性能。

[size=11.818181991577148px]测试性能程序：

1. import java.util.HashMap;  
   
2. import java.util.Map;  
   
3. 
   
4. public class Test {  
   
5.        
   
6.             public static void main(String[] args) {  
   
7.           
   
8.                     long MAX = 100000L;  
   
9.                     int TIMES = 10;  
   
10.                      
    
11.                     Map<String, String> map1 = new HashMap<String, String>();  
    
12.                     Map<String, String> map2 = new HashMap<String, String>();
    
13. 
    
14.                 for (long i = 0; i < MAX; i++){  
    
15.                                 map1.put("a" + i, "aa" + i);  
    
16.                                 map2.put("b" + i, "bb" + i);  
    
17.                      }  
    
18.                 
    
19.                 String value = "";   
    
20.                 String key= "";  
    
21.                 long startTime, endTime;  
    
22.                 double total = 0;  
    
23.   
    
24.   
    
25.           
    
26.                /**
    
27.                 * 通过Map.keySet遍历key和value
    
28.                 */
    
29.                 for (int j = 0; j < TIMES; j++) {  
    
30.           
    
31.                     startTime = System.currentTimeMillis();  
    
32.                     for (String temp : map1.keySet()) {  
    
33.                         key = temp;  
    
34.                         value = map1.get(key);  
    
35.                     }  
    
36.                     endTime = System.currentTimeMillis();  
    
37.                     System.out.println("通过Map.keySet遍历key和value耗时 " + (endTime - startTime)  
    
38.                             + " ms ");  
    
39.                 }  
    
40.                 
    
41.                   
    
42.                   
    
43.               /**
    
44.                *通过Map.entrySet遍历key和value  
    
45.                */
    
46.                     startTime = System.currentTimeMillis();  
    
47.             for (Map.Entry<String, String> entry : map2.entrySet()) {  
    
48.                         key = entry.getKey();  
    
49.                         value = entry.getValue();  
    
50.                     }  
    
51.                     endTime = System.currentTimeMillis();  
    
52.                     System.out.println("通过Map.entrySet遍历key和value耗时 " + (endTime - startTime)  
    
53.                             + " ms ");  
    
54.                 }  
    
55. 
    
56.         }
    

复制代码

[size=11.818181991577148px]测试结果：

1. 通过Map.keySet遍历key和value耗时 5 ms
   
2. 通过Map.keySet遍历key和value耗时 3 ms
   
3. 通过Map.keySet遍历key和value耗时 3 ms
   
4. 通过Map.keySet遍历key和value耗时 3 ms
   
5. 通过Map.keySet遍历key和value耗时 3 ms
   
6. 通过Map.keySet遍历key和value耗时 3 ms
   
7. 通过Map.keySet遍历key和value耗时 3 ms
   
8. 通过Map.keySet遍历key和value耗时 4 ms
   
9. 通过Map.keySet遍历key和value耗时 3 ms
   
10. 通过Map.keySet遍历key和value耗时 3 ms
    
11. 通过Map.entrySet遍历key和value耗时 7 ms

复制代码

[size=11.818181991577148px]如果把上面的数字改动的大一些，可能效果更明显，但是改大的话，电脑会卡死掉。

很好！！！！

赞！赞！赞！赞！赞！赞！赞！赞！赞！