`
jetway
  • 浏览: 483836 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

首先，遍历map有以下方法：

多线程 
阅读更多

首先，遍历map有以下方法：

Java代码 复制代码
  1. import java.util.HashMap;   
  2. import java.util.Iterator;   
  3. import java.util.Map;   
  4.   
  5. public class MapTest {   
  6.   
  7.     public static void main(String[] args) {   
  8.         Map<String, String> map = new HashMap<String, String>();   
  9.         map.put("1", "1");   
  10.         map.put("2", "2");   
  11.         map.put("3", "3");   
  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.   
  44. }  
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MapTest {

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		map.put("1", "1");
		map.put("2", "2");
		map.put("3", "3");


		// 第一种：通过Map.keySet遍历key和value
		System.out.println("通过Map.keySet遍历key和value:");
		for (String key : map.keySet()) {
			System.out.println("key= " + key + "  and  value= " + map.get(key));
		}
		
		// 第二种：通过Map.entrySet使用iterator遍历key和value
		System.out.println("通过Map.entrySet使用iterator遍历key和value:");
		Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
		while (it.hasNext()) {
			Map.Entry<String, String> entry = it.next();

			System.out.println("key= " + entry.getKey() + "  and  value= "
					+ entry.getValue());
		}

		// 第三种：通过Map.entrySet遍历key和value
		System.out.println("通过Map.entrySet遍历key和value:");
		for (Map.Entry<String, String> entry : map.entrySet()) {
			System.out.println("key= " + entry.getKey() + "  and  value= "
					+ entry.getValue());
		}

		// 第四种：通过Map.values()遍历所有的value，但是不能遍历键key
		System.out.println("通过Map.values()遍历所有的value:");
		for (String v : map.values()) {
			System.out.println("value= " + v);
		}
	}

}

 

结果如下：

Java代码 复制代码
  1. 通过Map.keySet遍历key和value:   
  2. key= 3  and  value= 3  
  3. key= 2  and  value= 2  
  4. key= 1  and  value= 1  
  5. 通过Map.entrySet使用iterator遍历key和value:   
  6. key= 3  and  value= 3  
  7. key= 2  and  value= 2  
  8. key= 1  and  value= 1  
  9. 通过Map.entrySet遍历key和value:   
  10. key= 3  and  value= 3  
  11. key= 2  and  value= 2  
  12. key= 1  and  value= 1  
  13. 通过Map.values()遍历所有的value:   
  14. value= 3  
  15. value= 2  
  16. value= 1   
通过Map.keySet遍历key和value:
key= 3  and  value= 3
key= 2  and  value= 2
key= 1  and  value= 1
通过Map.entrySet使用iterator遍历key和value:
key= 3  and  value= 3
key= 2  and  value= 2
key= 1  and  value= 1
通过Map.entrySet遍历key和value:
key= 3  and  value= 3
key= 2  and  value= 2
key= 1  and  value= 1
通过Map.values()遍历所有的value:
value= 3
value= 2
value= 1

 

这四种方法都可以遍历map：

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

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

第四种比较少用，因为我们大多数时候都是同时需要key和value的

 

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

 

修改一下代码，对执行时间执行一下测试

 

Java代码 复制代码
  1. import java.util.HashMap;   
  2. import java.util.Map;   
  3.   
  4. public class MapTest {   
  5.     static long MAX_LONG = 1000000L;   
  6.     static int TIMES = 10;   
  7.     static Map<String, String> map1 = new HashMap<String, String>();   
  8.     static Map<String, String> map2 = new HashMap<String, String>();   
  9.     static {   
  10.         for (long i = 0; i < MAX_LONG; i++) {   
  11.             map1.put("1" + i, "abc" + i);   
  12.             map2.put("2" + i, "def" + i);   
  13.         }   
  14.     }   
  15.   
  16.     public static void main(String[] args) {   
  17.   
  18.         String valueStr = "";    
  19.         String keyStr = "";   
  20.         long start, end;   
  21.         double totalMs;   
  22.   
  23.   
  24.   
  25.         totalMs = 0;   
  26.         for (int i = 0; i < TIMES; i++) {   
  27.   
  28.             // 通过Map.keySet遍历key和value   
  29.             start = System.currentTimeMillis();   
  30.             for (String key : map1.keySet()) {   
  31.                 keyStr = key;   
  32.                 valueStr = map1.get(key);   
  33.             }   
  34.             end = System.currentTimeMillis();   
  35.             System.out.println("通过Map.keySet遍历key和value耗时 " + (end - start)   
  36.                     + " ms ");   
  37.             totalMs += (end - start);   
  38.         }   
  39.         System.out.println("Times : " + TIMES + ", totalMs : " + totalMs   
  40.                 + "ms, average :" + totalMs / TIMES + "ms");   
  41.            
  42.            
  43.         totalMs = 0;   
  44.         for (int i = 0; i < TIMES; i++) {   
  45.             // 通过Map.entrySet遍历key和value   
  46.             start = System.currentTimeMillis();   
  47.             for (Map.Entry<String, String> entry : map2.entrySet()) {   
  48.                 keyStr = entry.getKey();   
  49.                 valueStr = entry.getValue();   
  50.             }   
  51.             end = System.currentTimeMillis();   
  52.             System.out.println("通过Map.entrySet遍历key和value耗时 " + (end - start)   
  53.                     + " ms ");   
  54.             totalMs += (end - start);   
  55.         }   
  56.         System.out.println("Times : " + TIMES + ", totalMs : " + totalMs   
  57.                 + "ms, average :" + totalMs / TIMES + "ms");   
  58.   
  59.     }   
  60.   
  61. }  
import java.util.HashMap;
import java.util.Map;

public class MapTest {
	static long MAX_LONG = 1000000L;
	static int TIMES = 10;
	static Map<String, String> map1 = new HashMap<String, String>();
	static Map<String, String> map2 = new HashMap<String, String>();
	static {
		for (long i = 0; i < MAX_LONG; i++) {
			map1.put("1" + i, "abc" + i);
			map2.put("2" + i, "def" + i);
		}
	}

	public static void main(String[] args) {

		String valueStr = ""; 
		String keyStr = "";
		long start, end;
		double totalMs;



		totalMs = 0;
		for (int i = 0; i < TIMES; i++) {

			// 通过Map.keySet遍历key和value
			start = System.currentTimeMillis();
			for (String key : map1.keySet()) {
				keyStr = key;
				valueStr = map1.get(key);
			}
			end = System.currentTimeMillis();
			System.out.println("通过Map.keySet遍历key和value耗时 " + (end - start)
					+ " ms ");
			totalMs += (end - start);
		}
		System.out.println("Times : " + TIMES + ", totalMs : " + totalMs
				+ "ms, average :" + totalMs / TIMES + "ms");
		
		
		totalMs = 0;
		for (int i = 0; i < TIMES; i++) {
			// 通过Map.entrySet遍历key和value
			start = System.currentTimeMillis();
			for (Map.Entry<String, String> entry : map2.entrySet()) {
				keyStr = entry.getKey();
				valueStr = entry.getValue();
			}
			end = System.currentTimeMillis();
			System.out.println("通过Map.entrySet遍历key和value耗时 " + (end - start)
					+ " ms ");
			totalMs += (end - start);
		}
		System.out.println("Times : " + TIMES + ", totalMs : " + totalMs
				+ "ms, average :" + totalMs / TIMES + "ms");

	}

}

 以下是测试结果：

Java代码 复制代码
  1. 通过Map.keySet遍历key和value耗时 186 ms    
  2. 通过Map.keySet遍历key和value耗时 189 ms    
  3. 通过Map.keySet遍历key和value耗时 87 ms    
  4. 通过Map.keySet遍历key和value耗时 89 ms    
  5. 通过Map.keySet遍历key和value耗时 84 ms    
  6. 通过Map.keySet遍历key和value耗时 92 ms    
  7. 通过Map.keySet遍历key和value耗时 85 ms    
  8. 通过Map.keySet遍历key和value耗时 94 ms    
  9. 通过Map.keySet遍历key和value耗时 89 ms    
  10. 通过Map.keySet遍历key和value耗时 91 ms    
  11. Times : 10, totalMs : 1086.0ms, average :108.6ms   
  12. 通过Map.entrySet遍历key和value耗时 112 ms    
  13. 通过Map.entrySet遍历key和value耗时 98 ms    
  14. 通过Map.entrySet遍历key和value耗时 71 ms    
  15. 通过Map.entrySet遍历key和value耗时 65 ms    
  16. 通过Map.entrySet遍历key和value耗时 65 ms    
  17. 通过Map.entrySet遍历key和value耗时 64 ms    
  18. 通过Map.entrySet遍历key和value耗时 64 ms    
  19. 通过Map.entrySet遍历key和value耗时 65 ms    
  20. 通过Map.entrySet遍历key和value耗时 65 ms    
  21. 通过Map.entrySet遍历key和value耗时 65 ms    
  22. Times : 10, totalMs : 734.0ms, average :73.4ms   
通过Map.keySet遍历key和value耗时 186 ms 
通过Map.keySet遍历key和value耗时 189 ms 
通过Map.keySet遍历key和value耗时 87 ms 
通过Map.keySet遍历key和value耗时 89 ms 
通过Map.keySet遍历key和value耗时 84 ms 
通过Map.keySet遍历key和value耗时 92 ms 
通过Map.keySet遍历key和value耗时 85 ms 
通过Map.keySet遍历key和value耗时 94 ms 
通过Map.keySet遍历key和value耗时 89 ms 
通过Map.keySet遍历key和value耗时 91 ms 
Times : 10, totalMs : 1086.0ms, average :108.6ms
通过Map.entrySet遍历key和value耗时 112 ms 
通过Map.entrySet遍历key和value耗时 98 ms 
通过Map.entrySet遍历key和value耗时 71 ms 
通过Map.entrySet遍历key和value耗时 65 ms 
通过Map.entrySet遍历key和value耗时 65 ms 
通过Map.entrySet遍历key和value耗时 64 ms 
通过Map.entrySet遍历key和value耗时 64 ms 
通过Map.entrySet遍历key和value耗时 65 ms 
通过Map.entrySet遍历key和value耗时 65 ms 
通过Map.entrySet遍历key和value耗时 65 ms 
Times : 10, totalMs : 734.0ms, average :73.4ms

 可以看出，百万级别的量时，使用keySet和entrySet遍历，执行时间大概为1.5：1，这并不是最主要的差异。真正的差异还是必须看代码

Java代码 复制代码
  1. map.get(key))  
map.get(key))

时执行的hash操作

Java代码 复制代码
  1. /**  
  2.  * Returns the value to which the specified key is mapped,  
  3.  * or {@code null} if this map contains no mapping for the key.  
  4.  *  
  5.  * <p>More formally, if this map contains a mapping from a key  
  6.  * {@code k} to a value {@code v} such that {@code (key==null ? k==null :  
  7.  * key.equals(k))}, then this method returns {@code v}; otherwise  
  8.  * it returns {@code null}.  (There can be at most one such mapping.)  
  9.  *  
  10.  * <p>A return value of {@code null} does not <i>necessarily</i>  
  11.  * indicate that the map contains no mapping for the key; it's also  
  12.  * possible that the map explicitly maps the key to {@code null}.  
  13.  * The {@link #containsKey containsKey} operation may be used to  
  14.  * distinguish these two cases.  
  15.  *  
  16.  * @see #put(Object, Object)  
  17.  */  
  18. public V get(Object key) {   
  19.     if (key == null)   
  20.         return getForNullKey();   
  21.     int hash = hash(key.hashCode());   
  22.     for (Entry<K,V> e = table[indexFor(hash, table.length)];   
  23.          e != null;   
  24.          e = e.next) {   
  25.         Object k;   
  26.         if (e.hash == hash && ((k = e.key) == key || key.equals(k)))   
  27.             return e.value;   
  28.     }   
  29.     return null;   
  30. }  
    /**
     * Returns the value to which the specified key is mapped,
     * or {@code null} if this map contains no mapping for the key.
     *
     * <p>More formally, if this map contains a mapping from a key
     * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
     * key.equals(k))}, then this method returns {@code v}; otherwise
     * it returns {@code null}.  (There can be at most one such mapping.)
     *
     * <p>A return value of {@code null} does not <i>necessarily</i>
     * indicate that the map contains no mapping for the key; it's also
     * possible that the map explicitly maps the key to {@code null}.
     * The {@link #containsKey containsKey} operation may be used to
     * distinguish these two cases.
     *
     * @see #put(Object, Object)
     */
    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

 

计算hashCode是CPU密集运算，非常耗费CPU资源，如果对一个比较大的map进行遍历，会出现CPU迅速飚高的现象，直接影响机器的响应速度，在多线程的情况下，简直就是一场灾难，而采用entrySet来进行遍历，则无此问题，对这个有兴趣的同学，可以使用自己的机器试一试。

分享到：
| ThreadLocal
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JAVA遍历Map所有元素.doc

    本文将详细讲解两种主要的遍历Map元素的方法，并分析它们的效率差异。 ### 方法一：通过`entrySet()`遍历 这是推荐的遍历Map元素的方式，因为它具有较高的效率。通过调用`Map.entrySet()`方法，我们可以获取到Map...

    遍历Map集合.pdf

    在遍历Map时，我们通常有三种方式： 1. 使用keySet方法获取所有键，然后遍历这些键，通过键来获取对应的值。 示例代码如下： ```java Map, String&gt; map = new HashMap(); map.put("a", "1"); map.put("b", "2...

    在jsp中使用JSTL跟El表达式访问和遍历Map集合

    本篇将详细介绍如何在JSP中利用JSTL与EL表达式来访问和遍历Map集合。 首先，JSTL是一个标准的标签库，它提供了一系列预定义的标签，用于处理常见的任务，如迭代、条件判断、XML处理等，避免了在JSP页面中直接写Java...

    FreeMarker 遍历list

    3. **遍历Map**：使用`&lt;#list&gt;`指令，我们遍历`dataList`中的每一个Map对象，然后再次使用`&lt;#list&gt;`遍历Map中的每一个键值对。 4. **输出结果**：`${key}`和`${value}`分别代表Map中的键和对应的值，它们会被替换为...

    struts2中的map遍历

    在Struts2中，我们可以使用OGNL（Object-Graph Navigation Language）表达式语言来遍历Map。 在Struts2中，Map遍历通常在JSP页面上进行，使用OGNL表达式。以下是一个简单的例子： ```jsp ... &lt;s:iterator value=...

    dom遍历所有xml节点，并且重新生成xml

    首先，让我们了解XML的基本结构。XML（eXtensible Markup Language）是一种可扩展标记语言，常用于存储和传输数据。一个XML文档由元素（Element）、属性（Attribute）、文本（Text）、注释（Comment）和处理指令...

    java实现遍历Map的方法

    首先，Java提供了两种主要的方式来遍历Map：迭代器（Iterator）方式和增强for循环（foreach）方式。 ### 1. 迭代器方式 迭代器方式是通过调用Map的`keySet()`方法获取所有的键，然后通过迭代器遍历这些键，再使用`...

    Java遍历Map键、值和获取Map大小的方法示例

    首先，我们来看第一种遍历Map的方法，这是通过Map的`keySet()`方法实现的。`keySet()`方法返回一个Set集合，该集合包含了Map中所有的键。我们可以遍历这个Set集合，然后通过`map.get(key)`方法获取对应的值。以下是...

    Struts2 使用OGNL遍历map方法详解

    总结来说，Struts2的OGNL遍历Map方法是其强大功能的一部分，它简化了从Action到视图的数据传递过程，使得处理复杂的Java对象和数据结构变得轻松易行。在实际开发中，理解并熟练掌握OGNL的用法，能够显著提升工作效率...

    Js遍历键值对形式对象或Map形式的方法

    遍历Map对象的方法略有不同，主要有以下两种： 1. 使用`for...of`循环和`entries()`方法： ```javascript let map = new Map(); map.set('name', 'John'); map.set('age', 30); for (let [key, value] of map...

    How to Iterate Over a Map in Java

    首先，Java中的Map接口定义了几个方法来遍历Map，它们是`entrySet()`，`keySet()`和`values()`。这些方法返回的集合对象分别代表Map的所有条目、所有键和所有值，可以用来进行迭代操作。 1. 使用`entrySet()`遍历...

    VC++遍历对话框中的子控件

    遍历对话框中的子控件主要涉及到以下步骤： 1. **获取对话框的句柄**：使用`GetDlgItem`函数，传入对话框资源ID，可以获取到`CDialog`对象的指针。 2. **遍历子控件**：使用`EnumChildWindows`函数，这是一个全局...

    freemaker学习教程

    首先，我们要明白在FreeMarker中直接遍历Map的特殊性。由于FreeMarker的设计，当你尝试直接在模板中遍历一个Map，它实际上会遍历Map的所有键（key），而不是值（value）。这是因为FreeMarker默认不直接支持遍历Map的...

    Struts2 JSP中将list,set ,Map传递到Action然后<s:iterator>遍历（三十五）

    本文将深入探讨如何在JSP中将`List`, `Set`, `Map`等集合类型的数据传递到Action，然后再通过`&lt;s:iterator&gt;`标签进行遍历显示。这种方式对于数据的展示和交互具有重要的实践意义。 首先，我们需要了解Struts2的工作...

    Java 实例 - HashMap遍历源代码-详细教程.zip

    - **foreach循环**：Java 5引入了增强的for循环（也称为foreach），可以直接遍历Map的键值对，例如：`for (Map.Entry, Value&gt; entry : map.entrySet()) {...}` 4. **源代码解析**： - `put`操作：当插入新的键值...

    地图文档图层遍历输出

    实现"地图文档图层遍历输出"，我们需要以下步骤： 1. **导入必要的库**：首先，我们需要导入`arcpy`模块，它是Python ArcGIS API的核心，用于执行GIS操作。 2. **打开地图文档**：使用`arcpy.mp.ArcGISProject`类...

    vue使用map代替Aarry数组循环遍历的方法

    使用Map对象代替数组，主要有以下几个步骤： 1. 在Vue组件的data函数中定义一个Map类型的全局变量，用于存储键值对： ```javascript data() { return { indexMap: new Map() }; } ``` 2. 在组件创建或者获取到...

    List、Set、Map的特点及遍历方法

    遍历Map有以下几种方式： 1. 遍历所有的键，并通过键获取对应的值。 ```java for (Object key : map.keySet()) { Object value = map.get(key); System.out.println("Key: " + key + ", Value: " + value); } ```...

    MAP和vector的用法

    // 使用迭代器遍历map for (auto it = student_scores.begin(); it != student_scores.end(); ++it) { std::cout 学生: " &lt;&lt; it-&gt;first , 分数: " &lt;&lt; it-&gt;second &lt;&lt; std::endl; } return 0; } ``` 其次，`std...

    Java读取Map的两种方法与对比

    本文将详细介绍两种常见的遍历Map的方法，并通过性能测试进行对比。 一、遍历Map的方法 1. 方法A： ```java Map map = new HashMap(); Iterator iter = map.entrySet().iterator(); while (iter.hasNext()) { Map...

Magicbox
Global site tag (gtag.js) - Google Analytics