下载文档原格式
map循环遍历方式Map循环遍历是一种常见的遍历方式，它可以用于数组、对象、集合等多种数据类型的遍历操作。
在本文中，我们将详细介绍Map循环遍历的步骤及注意事项。
一、什么是MapMap是一种键值对集合，它类似于对象，但不同之处在于它的键可以是任意类型。
Map可以用于存储需要通过键来访问的数据，如对象中的属性。
在ES6之前，我们通常使用对象来存储数据，但是当我们需要存储非字符串类型的键时，将会遇到一些问题。
因此，ES6引入了Map来解决这个问题。
二、Map的遍历方式Map具有三种遍历方式，分别为forEach()、for-of和for-each。
其中，forEach()和for-of通常是我们使用最多的两种方式。
接下来，我们将分别介绍这两种遍历方式的步骤及注意事项。
1.使用forEach()遍历MapforEach()是一个数组的遍历方法，但是它也可以用于遍历Map。
使用forEach()遍历Map时，需要注意以下几点：（1）forEach()遍历Map时会将每个键值对作为参数传递给回调函数，回调函数的第一个参数为value，第二个参数为key。
（2）在回调函数中，this指向全局对象window。
（3）forEach()不能中途停止或跳出。
下面是使用forEach()遍历Map的示例代码：```let map = new Map([['name', 'Tom'],['age', 18]]);map.forEach(function(value, key) {console.log(key + ": " + value);});```输出结果为：```name: Tomage: 18```2.使用for-of遍历Mapfor-of是ES6引入的一个新的循环语句，它可以用于遍历数组、字符串、Map等可迭代对象。
使用for-of遍历Map时，需要注意以下几点：（1）for-of遍历Map时会将每个键值对作为数组返回，数组的第一个元素为key，第二个元素为value。
Java集合之——遍历Map对象的4种⽅法⽅法⼀通过Map.entrySet遍历key和value，在for-each循环中使⽤entries来遍历.推荐，尤其是容量⼤时这是最常见的并且在⼤多数情况下也是最可取的遍历⽅式。
在键值都需要时使⽤。
1 Map<Integer, Integer> map = new HashMap<Integer, Integer>();23for (Map.Entry<Integer, Integer> entry : map.entrySet()) {45 System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());67 }⽅法⼆、通过Map.keySet遍历key，通过键找值value遍历（效率低）,普遍使⽤，⼆次取值1 Map<Integer, Integer> map = new HashMap<Integer, Integer>();23for (Integer key : map.keySet()) {45 Integer value = map.get(key);67 System.out.println("Key = " + key + ", Value = " + value);89 }⽅法三如果只需要map中的键或者值，你可以通过Map.keySet或Map.values来实现遍历，⽽不是⽤entrySet。
在for-each循环中遍历keys或values。
1 Map<Integer, Integer> map = new HashMap<Integer, Integer>();23//遍历map中的键45for (Integer key : map.keySet()) {67 System.out.println("Key = " + key);89 }1011//遍历map中的值1213for (Integer value : map.values()) {1415 System.out.println("Value = " + value);1617 }⽅法四:通过Map.entrySet使⽤iterator遍历key和value1 Map<Integer, Integer> map = new HashMap<Integer, Integer>();23 Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();45while (entries.hasNext()) {67 Map.Entry<Integer, Integer> entry = entries.next();89 System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());1011 }=================================我=======是=======分=======割=======线=================================全部代码：1public static void main(String[] args) {2 init();3 traversal();4 }56// HashMap按照哈希算法来存取键对象，有很好的存取性能7private static HashMap<String, String> hMap = new HashMap<>();89// TreeMap实现了SortedMap接⼝，能对键对象进⾏排序。
遍历Map的⼏种⽅式Java代码Map<String,String> map=new HashMap<String,String>();map.put("username", "qq");map.put("passWord", "123");map.put("userID", "1");map.put("email", "qq@");第⼀种⽤for循环Java代码for(Map.Entry<String, String> entry:map.entrySet()){System.out.println(entry.getKey()+"--->"+entry.getValue());}第⼆种⽤迭代Java代码Set set = map.entrySet();Iterator i = set.iterator();while(i.hasNext()){Map.Entry<String, String> entry1=(Map.Entry<String, String>)i.next();System.out.println(entry1.getKey()+"=="+entry1.getValue());}⽤keySet()迭代Java代码Iterator it=map.keySet().iterator();while(it.hasNext()){String key;String value;key=it.next().toString();value=map.get(key);System.out.println(key+"--"+value);}⽤entrySet()迭代Java代码Iterator it=map.entrySet().iterator();System.out.println( map.entrySet().size());String key;String value;while(it.hasNext()){Map.Entry entry = (Map.Entry)it.next();key=entry.getKey().toString();value=entry.getValue().toString();System.out.println(key+"===="+value);} for (Map.Entry<String, String> entry : map.entrySet()) { System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue()); }。
Javamap详解-⽤法、遍历、排序、常⽤API等原⽂地址; https:///view/250.html#1Map⽤法类型介绍Java ⾃带了各种 Map 类，这些 Map 类可归为三种类型：通⽤Map⽤于在应⽤程序中管理映射，通常在 java.util 程序包中实现HashMap、Hashtable、Properties、LinkedHashMap、IdentityHashMap、TreeMap、WeakHashMap、ConcurrentHashMap专⽤Map通常我们不必亲⾃创建此类Map，⽽是通过某些其他类对其进⾏访问java.util.jar.Attributes、javax.print.attribute.standard.PrinterStateReasons、java.security.Provider、java.awt.RenderingHints、javax.swing.UIDefaults⾃⾏实现Map⼀个⽤于帮助我们实现⾃⼰的Map类的抽象类AbstractMap类型区别HashMap最常⽤的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。
HashMap最多只允许⼀条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。
⾮同步的。
TreeMap能够把它保存的记录根据键(key)排序,默认是按升序排序，也可以指定排序的⽐较器，当⽤Iterator 遍历TreeMap时，得到的记录是排过序的。
TreeMap不允许key的值为null。
⾮同步的。
Hashtable与 HashMap类似,不同的是:key和value的值均不允许为null;它⽀持线程的同步，即任⼀时刻只有⼀个线程能写Hashtable,因此也导致了Hashtale在写⼊时会⽐较慢。
LinkedHashMap保存了记录的插⼊顺序，在⽤Iterator遍历LinkedHashMap时，先得到的记录肯定是先插⼊的.在遍历的时候会⽐HashMap慢。
javamapforeach_Java遍历Map的5种⽅法Map作为Java中的⼀种集合，以键值对的形式存放⼀批数据，经常会被我们应⽤在项⽬中。
既然是⼀种集合，⾃然就有需要遍历的场景。
今天就来说5种遍历Map的⽅法。
01通过map对象的entrySet遍历Map通过map.entrySet()⽅法，可以获取到⼀个set集合，⽽这个集合的每⼀个元素就是⼀个键值对。
如此就可以通过遍历通过map.entrySet()获取到的set集合来达到遍历Map的⽬的了。
⽰例代码展⽰⼀下。
通过这种⽅式，可以同时遍历到Map的key和value。
02通过迭代器(Iterator)的⽅式遍历Map遍历集合的地⽅就少不了会出现迭代器(Iterator)的⾝影。
下⾯来⼀段⽰例，看看怎么通过迭代器(Iterator)来遍历Map。
看过我之前写的《我们来看看Java的foreach的真⾯⽬吧》这篇⽂章的朋友，应该知道。
第⼀种遍历⽅式其实是第⼆种遍历⽅式通过语法糖做的⼀种编码⽅式，也就是第⼀种遍历⽅式在编译后实际就是第⼆种遍历⽅式了。
03通过map对象的keySet()遍历Map通过map.keySet()⽅法可以获取到存放了Map的所有key的⼀个Set。
然后通过遍历这个Set就可以做到遍历Map的效果了。
具体看下⾯的⽰例代码。
通过这种⽅式，可以遍历到Map的key，如果想要同时遍历到Map的value，就需要通过key来从Map这个集合中获取对应的value了。
04通过map对象的values()遍历Map上⾯是通过遍历key来实现遍历Map的效果。
那是不是也能遍历value来达到遍历Map的效果呢。
答案是有的，通过map.values()就可以获取到存放了Map中所有value的⼀个集合了。
然后就可以通过遍历这个value的集合来达到遍历Map的⽬的了。
具体怎么实现看下⾯的⽰例代码。
通过这种⽅式遍历Map的话，只能遍历到Map的所有value，但是⽆法获取Map的key。
import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Map.Entry;importjava.util.Set;publicclassMapTest{privateMap<String,String> map;publicMapTest(){map =newHashMap<String,String>();map.put("1","第一个数");map.put("2","第二个数");map.put("3","第三个数");}// 第一种方法（传统方法）publicvoid mapOne(){Set<String> set =map.keySet();Iterator<String> it =set.iterator();while(it.hasNext()){String key =(String)it.next();String value =(String)map.get(key);System.out.println(key +"="+ value);}}// 第二种方法（传统方法）publicvoid mapTwo(){Set set = map.entrySet();Iterator it =set.iterator();while(it.hasNext()){Entry entry =(Entry)it.next();String key =(String) entry.getKey();String value=(String) entry.getValue();System.out.println(key +"="+ value);}}// 第三种方法（增强for循环方法）publicvoidmapThree(){for(Object obj : map.keySet()){String key =(String)obj;String value =(String)map.get(key);System.out.println(key +"="+ value);}}// 第四种方法（增强for循环方法）publicvoidmapFour(){for(Object obj : map.entrySet()){Entry entry=(Entry) obj;String key =(String) entry.getKey();String value =(String) entry.getValue();System.out.println(key +"="+ value);}}publicstaticvoid main(String[] args){MapTest mapTest =newMapTest();System.out.println("=====first=====");mapTest.mapOne();System.out.println("=====second=====");mapTest.mapTwo();System.out.println("=====three=====");mapTest.mapThree();System.out.println("=====four=====");mapTest.mapFour();}}输出结果：=====first=====3=第三个数2=第二个数1=第一个数=====second=====3=第三个数2=第二个数1=第一个数=====three=====3=第三个数2=第二个数1=第一个数=====four=====3=第三个数2=第二个数1=第一个数public static void main(String[] args) {Map<String, String> map = new HashMap<String, String>();map.put("1", "value1");map.put("2", "value2");map.put("3", "value3");//第一种：普遍使用，二次取值System.out.println("通过Map.keySet遍历key和value：");for (String key : map.keySet()){ System.out.println("key= "+ key + " and value= " + map.get(key)); }//第二种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()); }//第三种：推荐，尤其是容量大时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()); }//第四种System.out.println("通过Map.values()遍历所有的value，但不能遍历key");for (String v : map.values()) { System.out.println("value= " + v); } }。
java 遍历map方法Java中Map是一种常见的数据结构，用于存储键值对。
遍历Map 可以通过多种方法实现。
以下是常用的几种遍历Map的方法：1. 通过键遍历Map遍历Map的最基本方法是通过键来循环Map。
可以使用Map接口的keySet()方法获取所有键的集合，然后循环集合并通过get()方法获取对应的值。
示例代码：Map<String, Integer> map = new HashMap<>();map.put('A', 1);map.put('B', 2);map.put('C', 3);for (String key : map.keySet()) {Integer value = map.get(key);System.out.println(key + '：' + value);}输出结果：A：1B：2C：32. 通过值遍历Map如果需要查找Map中的某个值，可以使用values()方法获取所有值的集合，然后循环集合并通过contains()方法查找对应的值。
示例代码：Map<String, Integer> map = new HashMap<>();map.put('A', 1);map.put('B', 2);map.put('C', 3);for (Integer value : map.values()) {if (value == 2) {System.out.println('找到了值为2的键值对');break;}}输出结果：找到了值为2的键值对3. 通过键值对遍历Map如果需要同时遍历Map中的键和值，可以使用entrySet()方法获取所有键值对的集合，然后循环集合并通过getKey()和getValue()方法获取对应的键和值。
Java中Map的遍历方法及性能测试这篇文章主要介绍了Java中Map的遍历方法及性能测试,本文讲解对HashMap、TreeMap进行对比测试,给出测试代码、测试结果和测试结论,需要的朋友可以参考下1. 阐述对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。
理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。
那么实际情况如何呢？为了解遍历性能的真实差距，包括在遍历key+value、遍历key、遍历value等不同场景下的差异，我试着进行了一些对比测试。
2. 对比测试一开始只进行了简单的测试，但结果却表明keySet的性能更好，这一点让我很是费解，不都说entrySet明显好于keySet吗？为了进一步地进行验证，于是采用了不同的测试数据进行更详细的对比测试。
2.1 测试数据2.1.1 HashMap测试数据HashMap-1，大小为100万，key和value均为String，key的值为1、2、3……1000000：复制代码代码如下:Map<String, String> map = new HashMap<String, String>();String key, value;for (i = 1; i <= num; i++) {key = "" + i;value = "value";map.put(key, value);}HashMap-2，大小为100万，key和value均为String，key的值为50、100、150、200、 (50000000)复制代码代码如下:Map<String, String> map = new HashMap<String, String>();String key, value;for (i = 1; i <= num; i++) {key = "" + (i * 50);value = "value";map.put(key, value);}2.1.2 TreeMap测试数据TreeMap-1，大小为100万，key和value均为String，key的值为1、2、3……1000000：复制代码代码如下:Map<String, String> map = new TreeMap<String, String>();String key, value;for (i = 1; i <= num; i++) {key = "" + i;value = "value";map.put(key, value);}TreeMap-2，大小为100万，key和value均为String，key的值为50、100、150、200、……、50000000，更离散：复制代码代码如下:Map<String, String> map = new TreeMap<String, String>();String key, value;for (i = 1; i <= num; i++) {key = "" + (i * 50);value = "value";map.put(key, value);}2.2 测试场景分别使用keySet、entrySet和values的多种写法测试三种场景：遍历key+value、遍历key、遍历value的场景。
java基础Map遍历map遍历⽅法：1.通过keySet取出Map中的数据,然后for-each循环2.通过EntrySet取出，foreach循环3.KeySet取出，Iterator遍历4.通过EntrySet取出，Iterator遍历1/**Map的四种遍历⽅式*/2//1.直接打印：{name=null, id=null, age=0}3 System.out.println(map);4//2.通过keySet取出Map中的数据,然后for-each循环:5//key：name--value：null key：id--value：null key：age--value：06 Set<String> keySet=map.keySet();//得到set集合7for (String key:keySet){8 System.out.print("key："+key+"--value："+map.get(key)+" ");9 }10 System.out.println();11//3.通过EntrySet取出，foreach循环12//key:name--value:null key:id--value:null key:age--value:013 Set<Map.Entry<String,Object>> entrySet=map.entrySet();//得到set集合14for (Map.Entry<String ,Object> entry:entrySet){15 System.out.print("key:"+entry.getKey()+"--value:"+entry.getValue()+" ");16 }17/**迭代器遍历*/18//4.KeySet取出，Iterator遍历19 Iterator<String>iterator1=keySet.iterator();//map.keySet(),得到set集合,可以通过迭代器遍历20while (iterator1.hasNext()){21 String key=iterator1.next();22 System.out.println("key:"+key+" value"+map.get(key));23 }2425//5.通过EntrySet取出，Iterator遍历26 Iterator<Map.Entry<String,Object>> iterator2=entrySet.iterator();//map.entrySet(),得到set集合，得到set集合,可以通过迭代器遍历27while (iterator2.hasNext()){28 Map.Entry<String,Object> entryIterator=iterator2.next();29 System.out.println("key:"+entryIterator.getKey()+" value:"+entryIterator.getValue());30 }统计⽂件中关键字：1package MapDemo;2/**3*统计⽂件中关键字的个数，利⽤Map4*@author:Archer-LCY5*@date:2018年3⽉13⽇下午1:12:456*/78import java.io.BufferedReader;9import java.io.FileReader;10import java.util.ArrayList;11import java.util.Arrays;12import java.util.HashMap;13import java.util.HashSet;14import java.util.List;15import java.util.Map;16import java.util.Set;17import java.util.TreeMap;1819public class CountLKeyword {20public static void main(String[] args) {21 Count_keyword();22 }2324public static void Count_keyword() {25final String fileName="src/MapDemo/CountLKeyword.java";26/*关键字*/27final String keywords="package,inport,public,class,static,void ,final,private,new,try.catch,while,null,if,continue,return";28//1、获得Java源⽂件中的字符串（⾏集合，StringBuffer）29 List<String> contentList=ReadSourceFile(fileName);30 Set<String> keywordsSet=new HashSet<>();31 keywordsSet.addAll(Arrays.asList(keywords.split(",")));//以“，”分割32//2、遍历集合关键字，统计每个集合在字符串中出现的次数--将关键字以键-值的⽅式存放在Map集合中 33 Map<String , Integer> keywordsMap=new HashMap<>();34for(String line:keywordsSet) {//外循环遍历关键字集合35for(String keyword:contentList) {//内循环遍历，源代码所有⾏36//统计每⼀⾏，keyword出现的次数（进⾏累加）3738int count=getKeywordcounts(line,keyword);39if(count==0) continue ;40if(keywordsMap.containsKey(keyword)) {41int oldCount =keywordsMap.get(keyword).intValue();42 keywordsMap.put(keyword, new Integer(count+oldCount));43 }else {44//将count放到map集合中45 keywordsMap.put(keyword, count);//关键字出现⼀次直接添加即可46 }47 }48 }4950//3、遍历Map集合（以关键字出现的次数来排序）51for(java.util.Map.Entry<String, Integer> entry: keywordsMap.entrySet()) {52 System.out.println(entry.getKey()+"\t"+entry.getValue());53 }54//排序显⽰55 System.out.println("----------------------------------------------------");56 Map<String, Integer> treeMap=new TreeMap<>(new MyTreeComparator(keywordsMap));57 treeMap.putAll(keywordsMap);58for(java.util.Map.Entry<String, Integer> entry: keywordsMap.entrySet()) {59 System.out.println(entry.getKey()+"\t"+entry.getValue());60 }61 }6263private static int getKeywordcounts(String line ,String keyword) {64if(line==null||line.length()==0)65return 0;66//注释跳过67if(line.startsWith("/*")||line.startsWith("*")||line.startsWith("//")||line.endsWith("*/"))68return 0;69int count=0;70 String strLine=new String(line);71int index=-1;72while((index=strLine.indexOf(keyword))!=-1) {73 count++;74 strLine=strLine.substring(index+keyword.length()+1);75 }76return count;77 }7879/**80 * 读取Java源⽂件，以字符串⽅式返回源⽂件所以内容81 * @param fileName82 * @return83*/84private static List<String> ReadSourceFile(String fileName){85 List<String> countentList =new ArrayList<>();86try (87 FileReader fReader=new FileReader(fileName);88 BufferedReader bReader=new BufferedReader(fReader);89 ){90 String line=null;91while((line=bReader.readLine())!=null){92if(line.trim().length()==1)93continue;94 countentList.add(line);95 }9697 } catch (Exception e) {98 e.printStackTrace();99 }100return countentList;101 }102 }。
map遍历的⼏种⽅式和效率问题⼀、map遍历的效率先创建⼀个map，添加好数据：Map<String, String> map = new HashMap<>();for (int i = 0; i < 1000000; i++) {map.put(i + "", i + "AA");}1、keySet的for循环⽅式：//只获取keypublic static void keySetForGetKey(Map<String, String> map){long startTime = System.currentTimeMillis();for (String key : map.keySet()) {}long endTime = System.currentTimeMillis();System.out.println("keySetForGetKey运⾏时间" + (endTime - startTime));}//获取key和valuepublic static void keySetForGetKeyAndValue(Map<String, String> map){long startTime = System.currentTimeMillis();for (String key : map.keySet()) {String value = map.get(key);}long endTime = System.currentTimeMillis();System.out.println("keySetForGetKeyAndValue运⾏时间" + (endTime - startTime));}2、keySet的iterator迭代器⽅式：//只获取keypublic static void keySetIteratorGetKey(Map<String, String> map){long startTime = System.currentTimeMillis();Iterator<String> iterator = map.keySet().iterator();while (iterator.hasNext()) {String key = iterator.next();}long endTime = System.currentTimeMillis();System.out.println("keySetIteratorGetKey运⾏时间" + (endTime - startTime));}//获取key和valuepublic static void keySetIteratorGetKeyAndValue(Map<String, String> map){long startTime = System.currentTimeMillis();Iterator<String> iterator = map.keySet().iterator();while (iterator.hasNext()) {String key = iterator.next();String value = map.get(iterator.next());}long endTime = System.currentTimeMillis();System.out.println("keySetIteratorGetKeyAndValue运⾏时间" + (endTime - startTime));}3、entrySet的for循环⽅式：//只获取keypublic static void entrySetForGetKey(Map<String, String> map){long startTime = System.currentTimeMillis();for (Entry<String, String> entry : map.entrySet()) {String key = entry.getKey();}long endTime = System.currentTimeMillis();System.out.println("entrySetForGetKey运⾏时间" + (endTime - startTime));}//获取key和valuepublic static void entrySetForGetKeyAndValue(Map<String, String> map){long startTime = System.currentTimeMillis();for (Entry<String, String> entry : map.entrySet()) {String key = entry.getKey();String value = entry.getValue();}long endTime = System.currentTimeMillis();System.out.println("entrySetForGetKeyAndValue运⾏时间" + (endTime - startTime));}4、entrySet的iterator迭代器⽅式：//只获取keypublic static void entrySetIteratorGetKey(Map<String, String> map){long startTime = System.currentTimeMillis();Iterator<Entry<String, String>> iterator = map.entrySet().iterator();while (iterator.hasNext()) {String key = iterator.next().getKey();}long endTime = System.currentTimeMillis();System.out.println("entrySetIteratorGetKey运⾏时间" + (endTime - startTime));}//获取key和valuepublic static void entrySetIteratorGetKeyAndValue(Map<String, String> map){long startTime = System.currentTimeMillis();Iterator<Entry<String, String>> iterator = map.entrySet().iterator();while (iterator.hasNext()) {String key = iterator.next().getKey();String value = iterator.next().getValue();}long endTime = System.currentTimeMillis();System.out.println("entrySetIteratorGetKeyAndValue运⾏时间" + (endTime - startTime));}最终的运⾏结果为：keySetForGetKey运⾏时间28keySetForGetKeyAndValue运⾏时间43keySetIteratorGetKey运⾏时间25keySetIteratorGetKeyAndValue运⾏时间36entrySetForGetKey运⾏时间27entrySetForGetKeyAndValue运⾏时间28entrySetIteratorGetKey运⾏时间25entrySetIteratorGetKeyAndValue运⾏时间29总结：entrySet的⽅式整体都是⽐keySet⽅式要⾼⼀些( ★★★数据上表明：map.entrySet().iterator() 是最快的 )；单纯的获取key来说，两者的差别并不⼤，但是如果要获取value，还是entrySet的效率会更好，因为keySet需要从map中再次根据key获取value，⽽entrySet⼀次都全部获取出来；iterator的迭代器⽅式⽐foreach的效率⾼。
