57_Map集合遍历的四种方法
Java中遍历Map的四种方式
Java中遍历Map的四种⽅式⽅法⼀：在for循环中使⽤entries实现Map的遍历：1/**2* 最常见也是⼤多数情况下⽤的最多的，⼀般在键值对都需要使⽤3*/4 Map <String,String>map = new HashMap<String,String>();5 map.put("熊⼤", "棕⾊");6 map.put("熊⼆", "黄⾊");7for(Map.Entry<String, String> entry : map.entrySet()){8 String mapKey = entry.getKey();9 String mapValue = entry.getValue();10 System.out.println(mapKey+":"+mapValue);11 }⽅法⼆：在for循环中遍历key或者values，⼀般适⽤于只需要map中的key或者value时使⽤，在性能上⽐使⽤entrySet较好：1 Map <String,String>map = new HashMap<String,String>();2 map.put("熊⼤", "棕⾊");3 map.put("熊⼆", "黄⾊");4//key5for(String key : map.keySet()){6 System.out.println(key);7 }8//value9for(String value : map.values()){10 System.out.println(value);11 }⽅法三：通过Iterator遍历：1 Iterator<Entry<String, String>> entries = map.entrySet().iterator();2while(entries.hasNext()){3 Entry<String, String> entry = entries.next();4 String key = entry.getKey();5 String value = entry.getValue();6 System.out.println(key+":"+value);7 }⽅法四：通过键找值遍历，这种⽅式的效率⽐较低，因为本⾝从键取值是耗时的操作：1for(String key : map.keySet()){2 String value = map.get(key);3 System.out.println(key+":"+value);4 }。
Map常见的几种遍历方法
Map常见的⼏种遍历⽅法Map的遍历⽅法有很多种，各有优缺点，在实际运⽤中，我们应选择正确的遍历⽅法，以免出现不必要的错误。
下⾯简要介绍常⽤的⼏种遍历⽅法。
公共代码：1 Map<String, Integer> map = new HashMap<String, Integer>();2 map.put("Tom", 22);3 map.put("David", 20);4 map.put("Lily", 20);5 map.put("Lucy", 20);6 map.put("James", 21);7 map.put("Jim", 21);第⼀种⽅法：使⽤for循环的Entry遍历1// 最常见的也是最可取的遍历⽅式，通常在键值都需要时使⽤。
2for (Map.Entry<String, Integer> entry : map.entrySet()) {3 System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());4 }结果：第⼆种⽅法：使⽤for循环，按需遍历1// 如果只需要map中的键或者值，可以通过keySet或values来实现遍历。
2// 遍历键3for (String key : map.keySet()) {4 System.out.println("Key = " + key);5 }6// 遍历值7for (Integer value : map.values()) {8 System.out.println("value = " + value);9 }结果：第三种⽅法：使⽤Iterator遍历1// 使⽤Iterator遍历2 Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();3while (it.hasNext()) {4 Map.Entry<String, Integer> entry = it.next();5 System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());6 }结果：第四种⽅法：先遍历键，然后通过键找值1// 通过键找值遍历2for (String key : map.keySet()) {3 Integer value = map.get(key);4 System.out.println("Key = " + key + ", Value = " + value);5 }结果：总结，第⼀种⽅法是最常见的也是最可取的遍历⽅式，通常在键值都需要时使⽤；如果仅仅获取Map的键或值时，可以选择第⼆种⽅法；当JDK版本较低时，1.5以下，必须选择第三种⽅法，使⽤迭代器的遍历；第四种先遍历键，然后通过键找值，效率太低，很少使⽤。
map遍历的几种方式和效率问题
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的效率⾼。
Map的遍历方式
遍历Map的四种方法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);}}当一个人找不到出路的时候，最好的办法就是将当前能做好的事情做到极致，做到无人能及。
Map四种遍历方式
当一个人找不到出路的时候，最好的办法就是将当前能做好的事情做到极致，做到无人能及。
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.entrySet使用iterator遍历key和value：");
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {h
}
//第四种
System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
for (String v : map.values()) {
写出最有效率遍历map集合的方法
写出最有效率遍历map集合的方法下载温馨提示：该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。
文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by the editor. I hope that after you download them, they can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you!In addition, our shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!最有效率遍历Map集合的方法导言在软件开发中，Map（映射）是一种常见的数据结构，用于存储键值对。
Java中遍历Map集合的5种方式总结
Java中遍历Map集合的5种⽅式总结⽅式⼀通过Map.keySet使⽤iterator遍历@Testpublic void testHashMap1() {Map<Integer, String> map = new HashMap<>();map.put(001, "Java");map.put(002, "数据库");map.put(003, "Vue");System.out.println(map);// 通过Map.keySet使⽤iterator遍历key,然后通过key得到对应的value值Iterator<Integer> iterator = map.keySet().iterator();while (iterator.hasNext()) {Integer key = iterator.next();String value = map.get(key);System.out.println("key = " + key + ", value = " + value);}}结果：{1=Java, 2=数据库, 3=Vue}key = 1, value = Javakey = 2, value = 数据库key = 3, value = Vue⽅式⼆通过Map.entrySet使⽤iterator遍历@Testpublic void testHashMap2() {Map<Integer, String> map = new HashMap<>();map.put(001, "Java");map.put(002, "数据库");map.put(003, "Vue");System.out.println(map);// 通过Map.entrySet使⽤iterator遍历key和value；注意 Set entrySet()：返回所有key-value对构成的Set集合Iterator<Map.Entry<Integer, String>> entries = map.entrySet().iterator();while (entries.hasNext()) {Map.Entry<Integer, String> entry = entries.next();System.out.println(entry);}}结果：{1=Java, 2=数据库, 3=Vue}1=Java2=数据库3=Vue⽅式三通过Map.keySet遍历@Testpublic void testHashMap3() {Map<Integer, String> map = new HashMap<>();map.put(001, "Java");map.put(002, "数据库");map.put(003, "Vue");System.out.println(map);// 通过Map.keySet遍历key,然后通过key得到对应的value值for (Integer key : map.keySet()) {System.out.println("key = " + key + ", value = " + map.get(key));}}结果：{1=Java, 2=数据库, 3=Vue}key = 1, value = Javakey = 2, value = 数据库key = 3, value = Vue⽅式四通过For-Each迭代entries，使⽤Map.entrySet遍历@Testpublic void testHashMap4() {Map<Integer, String> map = new HashMap<>();map.put(001, "Java");map.put(002, "数据库");map.put(003, "Vue");System.out.println(map);// 使⽤For-Each迭代entries，通过Map.entrySet遍历key和valuefor (Map.Entry<Integer, String> entry : map.entrySet()) {System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());}}{1=Java, 2=数据库, 3=Vue}key = 1, value = Javakey = 2, value = 数据库key = 3, value = Vue⽅式五使⽤lambda表达式forEach遍历@Testpublic void testHashMap5() {Map<Integer, String> map = new HashMap<>();map.put(001, "Java");map.put(002, "数据库");map.put(003, "Vue");System.out.println(map);// 使⽤lambda表达式forEach遍历map.forEach((k, v) -> System.out.println("key = " + k + ", value = " + v));}forEach 源码default void forEach(BiConsumer<? super K, ? super V> action) {Objects.requireNonNull(action);for (Map.Entry<K, V> entry : entrySet()) {K k;V v;try {k = entry.getKey();v = entry.getValue();} catch(IllegalStateException ise) {// this usually means the entry is no longer in the map.throw new ConcurrentModificationException(ise);}action.accept(k, v);}}从源码可以看到，这种新特性就是在传统的迭代⽅式上加了⼀层壳，但是让代码变得更加简单。
Java遍历List或Map集合的4种方式
Java遍历List或Map集合的4种⽅式public class Test {public static void main(String[] args) {// 循环遍历List的4中⽅法List<String> strList = new ArrayList<>();strList.add("aaa");strList.add("bbb");strList.add("ccc");// 1. 普通遍历⽅式for (int i = 0; i < strList.size(); i++) {System.out.println(strList.get(i));}// 2.增强的for循环for (String str : strList) {System.out.println(str);}// 3. 使⽤Iterator迭代器Iterator<String> it = strList.iterator();while (it.hasNext()) {String str = (String) it.next();System.out.println(str);}// 4. java8 Lambda⽅式// strList.forEach(System.out::println);//和下⾯的写法等价strList.forEach(str -> {System.out.println(str);});}}⽅式⼀这是最常见的并且在⼤多数情况下也是最可取的遍历⽅式。
在键值都需要时使⽤。
Map<Integer, Integer> map = new HashMap<Integer, Integer>();for (Map.Entry<Integer, Integer> entry : map.entrySet()) {System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());}⽅法⼆在for-each循环中遍历keys或values。
map 遍历的方式
map 遍历的方式在JavaScript中，有多种方式可以遍历数组并使用`map`进行操作：1. 使用`for`循环：```javascriptconst arr = [1, 2, 3, 4, 5];const result = [];for (let i = 0; i < arr.length; i++) {result.push(arr[i] * 2);}console.log(result); // [2, 4, 6, 8, 10]```2. 使用`forEach`方法：```javascriptconst arr = [1, 2, 3, 4, 5];const result = [];arr.forEach((num) => {result.push(num * 2);});console.log(result); // [2, 4, 6, 8, 10]```3. 使用`map`方法：```javascriptconst arr = [1, 2, 3, 4, 5];const result = arr.map((num) => {return num * 2;});console.log(result); // [2, 4, 6, 8, 10]```4. 使用`for...of`循环（ES6）：```javascriptconst arr = [1, 2, 3, 4, 5];const result = [];for (let num of arr) {result.push(num * 2);}console.log(result); // [2, 4, 6, 8, 10]```这些方法都可以用于遍历数组并对每个元素执行相应的操作。
`map`方法是一种常用且便捷的方式，它返回一个新的数组，而不会修改原始数组。
根据具体的需求，你可以选择适合自己的遍历方式。
遍历Map集合、中的value值
遍历Map集合、中的value值Map集合是基于java核⼼类——java.util中的；Map集合⽤于储存元素对，Map储存的是⼀对键值（key和value），是通过key映射到它的valuevalues() : 是获取集合中的所有的值----没有键，没有对应关系。
KeySet() : 将Map中所有的键存⼊到set集合中。
因为set具备迭代器。
所有可以迭代⽅式取出所有的键，再根据get⽅法。
获取每⼀个键对应的值。
迭代后只能通过get()取key 。
entrySet()：是返回此映射中包含的映射关系的 Set 视图。
Map.Entry表⽰映射关系，迭代后可以e.getKey()，e.getValue()取key和value。
返回的是Entry接⼝。
for each遍历import java.util.Iterator;import java.util.Map;/*** @Title: mapTest* @Description:*/public class mapTest {public static void main(String[] args) {Map<String, String>map = new HashMap<String,String>();map.put("student2", "⼩李");map.put("student3", "⼩张");map.put("student4", "⼩王");//////1.使⽤entrySet()遍历System.out.println("使⽤entrySet()遍历");Iterator it = map.entrySet().iterator();while (it.hasNext()) {Map.Entry entry =(Map.Entry) it.next();Object key = entry.getKey();Object value = entry.getValue();System.out.println("key="+key+" value"+value);}//2.通过Map.Keyset遍历key和value,普遍使⽤，⼆次取值System.out.println("通过Map.Keyset遍历key和value,普遍使⽤，⼆次取值");for(String key:map.keySet()){System.out.println("Key="+key+"\tvalue="+map.get(key));}//3通过map.values()遍历所有的value，但不能遍历keySystem.out.println("通过map.values()遍历所有的value，但不能遍历key");for(String v:map.values()){System.out.println("value="+v);}//4通过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()+"\tvalue="+entry.getValue());}}}。
遍历集合的三种方法
遍历集合的三种方法一、概述集合是Java中常用的数据结构之一，它可以存储多个元素，并且可以进行添加、删除、查找等操作。
在实际开发中，我们经常需要遍历集合中的元素，以完成各种任务。
本文将介绍三种遍历集合的方法：for 循环遍历、迭代器遍历和forEach循环遍历。
二、for循环遍历for循环是Java中最基本的循环结构之一，它可以用来遍历数组和集合等数据结构。
对于集合来说，我们可以使用for-each语法来进行遍历。
具体实现如下：```List<String> list = new ArrayList<>();list.add("apple");list.add("banana");list.add("orange");for (String fruit : list) {System.out.println(fruit);}```上述代码中，我们首先创建了一个List对象，并向其中添加了三个元素。
然后使用for-each语法对该List进行了遍历，并打印出每个元素的值。
需要注意的是，在使用for-each语法进行遍历时，不能修改集合中的元素。
如果需要修改，则需要使用迭代器或普通for循环。
三、迭代器遍历迭代器是Java中专门用于访问集合元素的接口。
通过调用集合对象的iterator()方法可以获取一个迭代器对象，然后使用next()方法逐个访问集合中的元素。
具体实现如下：```List<String> list = new ArrayList<>();list.add("apple");list.add("banana");list.add("orange");Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {String fruit = iterator.next();System.out.println(fruit);}```上述代码中，我们首先创建了一个List对象，并向其中添加了三个元素。
遍历的集合的方法
遍历的集合的方法有多种方法可以遍历集合，以下是一些常见的方法：1. 使用for循环遍历：通过for循环逐个访问集合中的元素。
这对于数组和实现了Iterable接口的集合类都适用。
示例代码：List<String> list = Arrays.asList("A", "B", "C");for (String element : list) {System.out.println(element);}2. 使用迭代器遍历：可以使用集合的iterator()方法获取一个迭代器，然后使用while循环调用迭代器的next()方法来访问集合中的元素。
示例代码：List<String> list = Arrays.asList("A", "B", "C");Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {String element = iterator.next();System.out.println(element);}3. 使用forEach()方法遍历（Java 8及以上）：集合类提供了forEach()方法，可以使用Lambda表达式对集合中的每个元素进行操作。
示例代码：List<String> list = Arrays.asList("A", "B", "C");list.forEach(element -> System.out.println(element));4. 使用Stream API遍历（Java 8及以上）：可以将集合转换为流，在流中使用forEach()方法遍历元素。
Map的6种遍历方法
Map的6种遍历⽅法探讨有⼏种遍历Map的⽅法其实意义并不⼤，⽹上的⽂章⼀般讲4种或5种的居多，重要的是知道遍历的内涵，从遍历元素的⾓度来看，分为Key、Value、Map.Entry，从遍历的⽅法来看，分为foreach、Iterator。
即Map可以对Key、Value、Map.Entry分别执⾏foreach、Iterator遍历，所以总结有2*3=6种遍历⽅式。
提供实例如下。
源码如下package com;import java.util.HashMap;import java.util.Iterator;import java.util.Map;public class TestMapTraversal{public static void main(String[] args){Map<Integer, String> testmap = new HashMap<Integer, String>();testmap.put(100, "100");testmap.put(200, "200");System.out.println("\n------>1");//⽅法1:按照key foreachfor (Integer key : testmap.keySet()){System.out.println("key=" + key + ", value=" + testmap.get(key));}//⽅法2:按照key iteratorIterator<Integer> iterable2 = testmap.keySet().iterator();System.out.println("\n------>2");int key2;while(iterable2.hasNext()){key2 = iterable2.next();System.out.println("key=" + key2 + ", value=" + testmap.get(key2));}//⽅法3:按照Map.Entry foreachSystem.out.println("\n------>3");for (Map.Entry<Integer, String> entry : testmap.entrySet()){System.out.println("key=" + entry.getKey() + ", value=" + entry.getValue());}//⽅法4:按照Map.Entry IteratorSystem.out.println("\n------>4");Iterator iterator4 = testmap.entrySet().iterator();Map.Entry<Integer, String> entry4;while(iterator4.hasNext()){entry4 = (Map.Entry)iterator4.next();System.out.println("key=" + entry4.getKey() + ", value=" + entry4.getValue());}//⽅法5:按照value foreachSystem.out.println("\n------>5");for (String value : testmap.values()){System.out.println("value=" + value);}//⽅法6:按照value iteratorSystem.out.println("\n------>6");Iterator iterator6 = testmap.values().iterator();String value6;while(iterator6.hasNext()){value6 = (String)iterator6.next();System.out.println("value=" + value6);}}}运⾏结果如下------>1key=100, value=100key=200, value=200------>2key=100, value=100 key=200, value=200 ------>3key=100, value=100 key=200, value=200 ------>4key=100, value=100 key=200, value=200 ------>5value=100value=200------>6value=100value=200。
Java遍历Map对象的四种方式
Java遍历Map对象的四种⽅式关于java中遍历map具体哪四种⽅式，请看下⽂详解吧。
⽅式⼀这是最常见的并且在⼤多数情况下也是最可取的遍历⽅式。
在键值都需要时使⽤。
Map<Integer, Integer> map = new HashMap<Integer, Integer>();for (Map.Entry<Integer, Integer> entry : map.entrySet()) {System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());}⽅法⼆在for-each循环中遍历keys或values。
如果只需要map中的键或者值，你可以通过keySet或values来实现遍历，⽽不是⽤entrySet。
Map<Integer, Integer> map = new HashMap<Integer, Integer>();//遍历map中的键for (Integer key : map.keySet()) {System.out.println("Key = " + key);}//遍历map中的值for (Integer value : map.values()) {System.out.println("Value = " + value);}该⽅法⽐entrySet遍历在性能上稍好（快了10%），⽽且代码更加⼲净。
⽅法三使⽤Iterator遍历使⽤泛型：Map<Integer, Integer> map = new HashMap<Integer, Integer>();Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();while (entries.hasNext()) {Map.Entry<Integer, Integer> entry = entries.next();System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());}不使⽤泛型：Map map = new HashMap();Iterator entries = map.entrySet().iterator();while (entries.hasNext()) {Map.Entry entry = (Map.Entry) entries.next();Integer key = (Integer)entry.getKey();Integer value = (Integer)entry.getValue();System.out.println("Key = " + key + ", Value = " + value);}你也可以在keySet和values上应⽤同样的⽅法。
JavaMap集合遍历五种方式（包含Lambda表达式遍历）
JavaMap集合遍历五种⽅式（包含Lambda表达式遍历）⽰例代码如下：package mbda;import java.util.HashMap;import java.util.Iterator;import java.util.Map;/*** @author Miracle Luna* @version 1.0* @date 2019/6/9 21:41*/public class TraverseMap {public static void main(String[] args) {Map<String, String> map = new HashMap<String, String>();map.put("key1", "value1");map.put("key2", "value2");map.put("key3", "value3");// 第⼀种遍历⽅式System.out.println("第⼀种遍历⽅式：通过遍历 Map 的 keySet，遍历 Key 和 Value");for (String key : map.keySet()) {System.out.println("Key: " + key + ", Value: " + map.get(key));}// 第⼆种遍历⽅式(如果在遍历过程中，有删除某些Key-Value的需求，可以使⽤这种遍历⽅式)System.out.println("\n第⼆种遍历⽅式：通过Iterator 迭代器遍历 Key 和 Value");Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();while(iterator.hasNext()) {Map.Entry<String, String> entry = iterator.next();System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());}// 第三种遍历⽅式(推荐，尤其是容量⼤时)System.out.println("\n第三种遍历⽅式：通过遍历 Map 的 entrySet，遍历 Key 和 Value");for (Map.Entry<String, String> entry : map.entrySet()) {System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());}// 第四种遍历⽅式System.out.println("\n第四种遍历⽅式：通过遍历 Map 的 values，只能遍历 Value，获取不到对应的 Key");for (String value : map.values()) {System.out.println("Value: " + value);}// 第五种遍历⽅式（JDK 1.8⽀持的 Lambda 表达式，强烈推荐）System.out.println("\n第五种遍历⽅式：通过 Lambda 表达式，遍历 Key 和 Value");map.forEach((key, value) -> {System.out.println("Key: " + key + ", Value: " + value);});}}运⾏结果如下：第⼀种遍历⽅式：通过遍历 Map 的 keySet，遍历 Key 和 ValueKey: key1, Value: value1Key: key2, Value: value2Key: key3, Value: value3第⼆种遍历⽅式：通过Iterator 迭代器遍历 Key 和 ValueKey: key1, Value: value1Key: key2, Value: value2Key: key3, Value: value3第三种遍历⽅式：通过遍历 Map 的 entrySet，遍历 Key 和 ValueKey: key1, Value: value1Key: key2, Value: value2Key: key3, Value: value3第四种遍历⽅式：通过遍历 Map 的 values，只能遍历 Value，获取不到对应的 KeyValue: value1Value: value2Value: value3第五种遍历⽅式：通过 Lambda 表达式，遍历 Key 和 ValueKey: key1, Value: value1 Key: key2, Value: value2 Key: key3, Value: value3 PS：总结，参考如下：。
Map集合嵌套4种遍历方式
Map集合嵌套4种遍历⽅式⼀、俗称集合嵌套就是集合套集合⼆、分析 Map集合的嵌套⾃定义⼀个类：public class Person {private String name;private int age;public Person() { //有参和⽆参构造super();}public Person(String name, int age) {super(); = name;this.age = age;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic int hashCode() { //这个地⽅写hashcode是为了不让重复元素存⼊final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (age != other.age)return false;if (name == null) {if ( != null)return false;} else if (!name.equals())return false;return true;}@Overridepublic String toString() {return"Person [name=" + name + ", age=" + age + "]";}}//注意事项：①导包时注意②正确使⽤ entryset和keyset关键字③使⽤迭代器遍历时注意先创建集合，增强for正常遍历即可（因map⽆下标不可以使⽤普通for进⾏遍历）package com.oracle.demo01;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Map.Entry;import java.util.Set;public class Demo7 {public static void main(String[] args) {// ⼤mapHashMap<String, HashMap<Person, String>> oracle = new HashMap<String, HashMap<Person, String>>();// ⼩mapHashMap<Person, String> java1018 = new HashMap<Person, String>();HashMap<Person, String> java1227 = new HashMap<Person, String>();// 封装集合 //给⼩map赋值⽤put关键字java1018.put(new Person("C罗", 34), "踢⾜球");java1018.put(new Person("詹姆斯", 35), "打篮球");java1227.put(new Person("张继科", 28), "打乒乓球");java1227.put(new Person("朱婷", 22), "打排球");oracle.put("java1018", java1018); //给⼤map赋值同样⽤put关键字oracle.put("java1227", java1227);// entryset +iterator遍历// 1.获取⼤的Map的⼤结婚猪呢个对象Set集合Set<Map.Entry<String, HashMap<Person, String>>> bigentrys = oracle.entrySet();//上⾯⼤map⾥⾯写的泛型是什么这⾥就写什么 Iterator<Map.Entry<String, HashMap<Person, String>>> it = bigentrys.iterator();while (it.hasNext()) {Map.Entry<String, HashMap<Person, String>> bigentry = it.next();String bigkey = bigentry.getKey(); //获取⼤对象key值HashMap<Person, String> smallMap = bigentry.getValue(); //获取⼤对象value值Set<Entry<Person, String>> entrySet = smallMap.entrySet(); //创建⼩对象集合Iterator<Entry<Person, String>> sit = entrySet.iterator();while (sit.hasNext()) {Entry<Person, String> e = sit.next();System.out.println(bigkey + "..." + e.getKey() + "..." + e.getValue());}}System.out.println("=========================");// 2. entryset 增强for遍历Set<Entry<String, HashMap<Person, String>>> entrySet = oracle.entrySet();for (Entry<String, HashMap<Person, String>> e : entrySet) {String bigKey = e.getKey();HashMap<Person, String> hashMap = e.getValue();Set<Entry<Person, String>> entrySet2 = hashMap.entrySet();for (Entry<Person, String> e5 : entrySet2) {System.out.println(bigKey + "..." + e5.getKey() + "..." + e5.getValue());}}System.out.println("3.增强for=========================");// 3.增强for+keyset⽅法Set<String> keySet = oracle.keySet();for (String s : keySet) {HashMap<Person, String> h = oracle.get(s);Set<Person> h2 = h.keySet();for (Person p : h2) {System.out.println(s + "..." + p + "..." + h.get(p));}}System.out.println("4.迭代器========================="); //4. 迭代器+keyset⽅法Set<String> keySet2 = oracle.keySet();Iterator<String> ite = keySet2.iterator();while (ite.hasNext()) {String s = ite.next();HashMap<Person, String> hashMap = oracle.get(s);Set<Person> keySet3 = hashMap.keySet();Iterator<Person> it8 = keySet3.iterator();while (it8.hasNext()) {Person p1 = it8.next();System.out.println(s + "..." + p1 + "..." + hashMap.get(p1));}}}}欢迎各位⼤神指点和评论；。
遍历Map的几种方式
遍历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()); }。
遍历Map的四种方法
遍历Map的四种⽅法 1public static void main(String[] args) {23// 构建⼀个Map 初始值为3条数据4 Map<String, String> map = new HashMap<String, String>();5 map.put("1", "xiaqiu");6 map.put("2", "pangzi");7 map.put("3", "shouzi");89//第⼀种：普遍使⽤，⼆次取值10 System.out.println("通过Map.keySet遍历key和value：");11for (String key : map.keySet()) {12 System.out.println("key= "+ key + " and value= " + map.get(key));13 }1415//第⼆种:通过Iterator迭代器遍历循环Map.entrySet().iterator();16 System.out.println("通过Map.entrySet使⽤iterator遍历key和value：");17 Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();18while (it.hasNext()) {19 Map.Entry<String, String> entry = it.next();20 System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());21 }2223//第三种：笔者推荐，尤其是容量⼤时(相对来说⽐2好⼀点效率⾼)24 System.out.println("通过Map.entrySet遍历key和value");25for (Map.Entry<String, String> entry : map.entrySet()) {26 System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());27 }2829//第四种30 System.out.println("通过Map.values()遍历所有的value，但不能遍历key");31for (String v : map.values()) {32 System.out.println("value= " + v);33 }34 }。
Map遍历的几种方式
Map遍历的⼏种⽅式代码⽰例/*** @author liaowenhui* @date 2020/6/25 11:15*/public class TestMap {public static void main(String[] args) {Map<String, String> map = new HashMap<String, String>();map.put("1", "C++");map.put("2", "Java");map.put("3", "Python");//第⼀种：普遍使⽤，⼆次取值System.out.println("通过Map.keySet遍历key和value：");for (String key : map.keySet()) {System.out.println("key= "+ key + " value= " + map.get(key));}//第⼆种IteratorSystem.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() + " value= " + entry.getValue());}//第三种：推荐，尤其是容量⼤时//entrySet 只是遍历了⼀次就把 key 和 value 都放到了 entry 中，效率更⾼。