Map集合的遍历

Map集合遍历有两种方法

第一：mapEntry方式

第二：keySet方式

 

HashMap 和Hashtable 的区别

- HashMap允许键和值是null，而Hashtable不允许键或者值是null。

- Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。

- HashMap提供了可供应用迭代的键的集合，因此，HashMap是快速失败（具体看下文)的。另一方面，Hashtable提供了对键的列举(Enumeration)。

  - 一般认为Hashtable是一个遗留的类。

 

Map集合的第一种遍历方式【效率高】：

思路：这种方式的思想是把Map集合调用entrySet()方法整体保存到一个Set集合中，再迭代获取Entry对象，然后从Entry对象中取得key和value。效率高！！！

[java] view plain copy

1. public class HashMapTest {  
2.   
3.     public static void main(String[] args) {  
4.   
5.         /* 创建一个map集合 */  
6.         Map maps = new HashMap<>();  
7.   
8.         /* 往集合中添加数据 */  
9.         maps.put("id", "0113285");  
10.         maps.put("name", "张三");  
11.         maps.put("sex", "男");  
12.           
13.         /*出现两个相同的key,编译是不会报错的。但是不能保存到集合中*/  
14.         maps.put("id", "0113285");  
15.         /*key和value都可以是null值*/  
16.         maps.put(null, "hello");  
17.           
18.         System.out.println(maps.size());  
19.   
20.         /* 把maps集合存储到一个Set结合中，然后再调用iterator()方法,获取一个遍历的迭代器 */  
21.         Iterator it = maps.entrySet().iterator();  
22.         /* 遍历 */  
23.         while (it.hasNext()) {  
24.             /* 从迭代器中获取一个entry对象 */  
25.             Entry entry = (Entry) it.next();  
26.             /* 通过entry.getKey()的方法获取key值 */  
27.             System.out.println("key:" + entry.getKey());  
28.             /* 通过entry.getValue()的方法获取value值 */  
29.             System.out.println("value:" + entry.getValue());  
30.         }  
31.     }  
32.   
33. }  

注：

1:Map集合中key和value都可以是null值！

2:出现两个相同的key值，编译是不会报错的，但是只能保存一个对象到集合中！

第二种遍历方式【效率低】：

思路：这种方式的思想是把map集合的key存到一个Set集合中，再遍历key，然后通过key去获取对应的value值。效率比较低!!!

[java] view plain copy

1. public class HashMapTest {  
2.   
3.     public static void main(String[] args) {  
4.   
5.         /* 创建一个map集合 */  
6.         Map maps = new HashMap<>();  
7.   
8.         /* 往集合中添加数据 */  
9.         maps.put("id", "0113285");  
10.         maps.put("name", "张三");  
11.         maps.put("sex", "男");  
12.         maps.put(null, "hello");  
13.   
14.         /* 把map集合中的Key存储到一个Set集合中,然后调用itera()方法获取一个迭代器 */  
15.         Iterator it = maps.keySet().iterator();  
16.         /* 遍历key，通过key的值获取value */  
17.         while (it.hasNext()) {  
18.   
19.             /* 获取key */  
20.             Object key = it.next();  
21.             System.out.println("key:" + key);  
22.             /* 通过key值获取value值 */  
23.             Object value = maps.get(key);  
24.             System.out.println("value" + value);  
25.         }  
26.     }  
27.   
28. }  

上面老说entrySet的方式比keySet的方式效率高，真的吗？我么可以通过一个程序来测试一下：

[java] view plain copy

1. public class HashMapTest {  
2.   
3.     public static void main(String[] args) {  
4.           
5.         /*获取程序开始的时间*/  
6.         long startTime = System.currentTimeMillis();  
7.           
8.         /* 创建一个map集合 */  
9.         Map maps = new HashMap<>();  
10.         /*循环往集合中添加数据*/  
11.         for (int i =0; i<8000000; i++){  
12.             maps.put(i, "张三"+i);  
13.         }  
14.           
15.         /*调用第一种方式，测试运行时间*/  
16.         iteratorByEntrySet(maps);  
17.           
18.         /*调用第二种方式，测试运行时间*/  
19.         //iteratorByKeySet(maps);  
20.           
21.         /*获取程序借宿需要的时间*/  
22.         long endTime = System.currentTimeMillis();  
23.           
24.         System.out.println("通过EntrySet遍历的效率:" + (endTime - startTime));  
25.         //System.out.println("通过keySet遍历的效率:" + (endTime - startTime));  
26.           
27.     }  
28.       
29.     /** 
30.      * 通过keySet方式遍历Map集合 
31.      * @param map 
32.      */  
33.     public static void iteratorByKeySet(Map map){  
34.           
35.         /* 把map集合中的Key存储到一个Set集合中,然后调用itera()方法获取一个迭代器 */  
36.         Iterator it = map.keySet().iterator();  
37.         /* 遍历key，通过key的值获取value */  
38.         while (it.hasNext()){  
39.             /* 获取key */  
40.             Object key = it.next();  
41.             Object value = map.get(key);  
42.         }  
43.     }  
44.   
45.     /** 
46.      * 通过entrySet方式遍历Map集合 
47.      * @param map 
48.      */  
49.     public static void iteratorByEntrySet(Map map){  
50.         /* 把maps集合存储到一个Set结合中，然后再调用iterator()方法,获取一个遍历的迭代器 */  
51.         Iterator it = map.entrySet().iterator();  
52.           
53.         while (it.hasNext()){  
54.             /*获取Entry对象*/  
55.             Entry entry = (Entry) it.next();  
56.             /*从entry对象中直接获取key和value*/  
57.             Object key = entry.getKey();  
58.             Object value = entry.getValue();  
59.         }  
60.     }  
61. }  

运行程序我们可以发现：

entrySet遍历的时间为：15100ms

keySet遍历的时间为：24084ms

所以：entrySet的效率高于keySet !!!!