`
shuai1234
  • 浏览: 978361 次
  • 性别: Icon_minigender_1
  • 来自: 山西
社区版块
存档分类
最新评论

遍历大容量map的正确方法

    博客分类：
  • java
多线程 
阅读更多

首先，遍历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来进行遍历，则无此问题，对这个有兴趣的同学，可以使用自己的机器试一试。

分享到：
| 完全自由软件[WinScp+Putty+Pageant]之Publ ...
评论
发表评论

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

相关推荐

    java遍历大容量map的正确方法.pdf

    在Java编程中，遍历大容量的Map是一个常见的操作，特别是在处理大数据或内存优化的场景下，选择正确的遍历方式至关重要。以下是对标题和描述中提及的四种遍历Map方法的详细说明： 1. **通过Map.keySet遍历key和...

    Map (c++实现的简易map)

    - 迭代器：定义前向迭代器，实现`begin()`和`end()`方法，允许遍历`Map`。 自定义`Map`的一个挑战是实现高效的查找、插入和删除操作，这通常需要熟练掌握二叉搜索树的特性，尤其是红黑树的插入和旋转规则。此外，...

    java中map集合的用法.pdf

    在Java编程语言中，Map接口是集合框架的重要组成部分，它提供了键值对（Key-Value）的数据存储方式。Map不是列表或数组，它允许通过键来查找...选择合适的Map实现，以及正确地遍历和操作Map，都是提高程序性能的关键。

    java中map集合的用法.doc

    Java中的Map集合是一种存储键值对的数据结构，它允许通过键来访问对应的值。Map接口在Java的`java.util`包中定义，...通过选择合适的Map类型，调整大小，以及正确地遍历和操作Map，可以提高程序性能并避免潜在的问题。

    map元素映射，正确使用标准模板库

    本篇文章将深入探讨如何正确地使用`std::map`，以及它提供的各种函数。 一、map的基本结构与类型定义 `std::map`由键值对组成，每个元素都有一个唯一的键和一个相关联的值。它的基本定义如下： ```cpp template, ...

    Map容器的用法(STL).docx

    例如，可以定义一个包含整型和字符串的结构体`StudentInfo`，并重载`运算符，以便`map`可以正确排序这些元素。 8. **迭代器操作**: - `lower_bound(key)`返回第一个大于等于key的元素的迭代器。 - `upper_bound...

    stl_map.rar_V2

    7. **大小和容量**：`map::size()`返回元素数量，`map::empty()`检查Map是否为空，`map::max_size()`返回Map能容纳的最大元素数。 8. **迭代器**：Map提供了双向迭代器，支持前向和后向遍历。`iterator`用于读写，`...

    map效果

    5. **并发与线程安全**：在多线程环境下，不线程安全的Map如HashMap在并发操作下可能导致数据不一致，而线程安全的Map如Java的ConcurrentHashMap则能保证在并发环境下的正确性。 6. **性能优化**：选择合适的Map...

    Java集合Collection、List、Set、Map使用详细讲解.doc

    - **容器分类**：Java集合框架主要分为两大类：集合（Collection）和映射（Map）。集合类用于存储单一类型的元素，而Map则用于存储键值对。 2. **Collection接口** - **常用方法**：Collection接口提供了add、...

    test-map

    在测试过程中，理解如何创建、遍历和修改Map对象是非常重要的，因为这会直接影响到代码的性能和正确性。 当我们谈论“test-map”，我们可能在讨论以下几种情况： 1. 单元测试：这是针对代码中的最小可测试单元进行...

    易语言HashMap类

    初始容量是指哈希表在创建时预分配的空间大小，而负载因子则是衡量哈希表负载程度的一个参数，表示哈希表在达到多大比例的占用率时需要进行扩容。 2. **加入**：HashMap类提供`加入`方法，用于将键值对插入到哈希表...

    Java-HashMap.rar_hashmap_java hashmap

    4. **键值对**：键（Key）必须实现`hashCode()`和`equals()`方法，以确保正确的哈希计算和比较。值（Value）可以是任意对象。 5. **键的唯一性**：在`HashMap`中，键是唯一的，相同的键不能添加多次。如果尝试插入...

    Java集合Map常见问题_动力节点Java学院整理

    如果桶内形成链表，通过遍历链表并使用键对象的equals()方法来找到正确的键值对。 3. **获取值对象**：在获取值时，HashMap首先根据键的hashCode找到bucket，然后通过键的equals()方法与链表中的键进行比较，找到...

    Map_test:让它工作

    在这个项目中，开发者可能在创建或优化一个使用Map的功能，可能是为了提高性能、处理复杂的数据结构或者确保正确性。 描述提到“地图测试”，这可能指的是针对Map对象的单元测试或集成测试，以验证其在实际应用中的...

    5分钟搞定集合

    了解Map时，需理解键的唯一性、键值对的概念以及遍历Map的方法。 4. **容器的体系** 集合框架的设计是基于继承和接口的。例如，List、Set和Map都继承自AbstractCollection，提供了基本的集合操作。List接口继承自...

    C++hashmap的使用实例

    这个数据结构允许我们以接近常数时间的复杂度进行插入、查找和删除操作，极大地提高了程序的执行效率。下面我们将深入探讨`std::unordered_map`的使用、特性以及一些实例。 1. **引入头文件** 在C++中使用`std::...

    Java企业系列面试题(集合篇).docx

    在自定义类中，必须重写这两个方法以确保键的正确索引和查找。 10. **HashMap与Hashtable的区别**：HashMap允许null键和值，而Hashtable不允许。Hashtable是线程安全的，适合多线程环境，而HashMap则不是。HashMap...

    2021最新版数据结构与算法面试题手册 1.pdf

    因此，这两个方法在HashMap中的正确实现对于保证其精确性和正确性至关重要。 6. **使用Object作为HashMap的key**：当Object对象作为HashMap的key时，必须保证Object的hashCode()方法返回的哈希码不会改变，因为如果...

    java面试 集合中知识点 HashMap(JDK1.8)源码+底层数据结构分析 整理.pdf

    拉链法将链表和数组结合，确保了即使有哈希冲突，也能通过遍历链表找到正确的元素。 2. **JDK1.8之后**：在JDK1.8中，当链表长度超过8且数组长度超过64时，HashMap会将链表转换为红黑树。红黑树是一种自平衡二叉...

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