遍历map_遍历map集合 - CSDN
精华内容
参与话题
  • Java中如何遍历Map对象的4种方法

    万次阅读 多人点赞 2020-04-15 18:44:14
    在Java中如何遍历Map对象 How to Iterate Over a Map in Java 在java中遍历Map有不少的方法。我们看一下最常用的方法及其优缺点。 既然java中的所有map都实现了Map接口,以下方法适用于任何map实现(HashMap, ...

     

    在Java中如何遍历Map对象

    How to Iterate Over a Map in Java

    在java中遍历Map有不少的方法。我们看一下最常用的方法及其优缺点。

    既然java中的所有map都实现了Map接口,以下方法适用于任何map实现(HashMap, TreeMap, LinkedHashMap, Hashtable, 等等)

     

    方法一 在for-each循环中使用entries来遍历

    这是最常见的并且在大多数情况下也是最可取的遍历方式。在键值都需要时使用。

    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循环在java 5中被引入所以该方法只能应用于java 5或更高的版本中。如果你遍历的是一个空的map对象,for-each循环将抛出NullPointerException,因此在遍历前你总是应该检查空引用。

     

     

     

    方法二 在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上应用同样的方法。

     

     

    该种方式看起来冗余却有其优点所在。首先,在老版本java中这是惟一遍历map的方式。另一个好处是,你可以在遍历时调用iterator.remove()来删除entries,另两个方法则不能。根据javadoc的说明,如果在for-each遍历中尝试使用此方法,结果是不可预测的。

    从性能方面看,该方法类同于for-each遍历(即方法二)的性能。

     

    方法四、通过键找值遍历(效率低)

    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    
    for (Integer key : map.keySet()) {
    
        Integer value = map.get(key);
    
        System.out.println("Key = " + key + ", Value = " + value);
    
    }

     

     

    作为方法一的替代,这个代码看上去更加干净;但实际上它相当慢且无效率。因为从键取值是耗时的操作(与方法一相比,在不同的Map实现中该方法慢了20%~200%)。如果你安装了FindBugs,它会做出检查并警告你关于哪些是低效率的遍历。所以尽量避免使用。

     

     

     

    总结

    如果仅需要键(keys)或值(values)使用方法二。如果你使用的语言版本低于java 5,或是打算在遍历时删除entries,必须使用方法三。否则使用方法一(键值都要)。

     

    展开全文
  • 方法一:使用entrySet方法: 示例: public static void main(String[] args) { Map<String, String> param = new HashMap<>(8); param.put("1","A"); param.put("2","B"); param.p...

    方法一:使用entrySet方法:
    示例:

    public static void main(String[] args) {
            Map<String, String> param = new HashMap<>(8);
            param.put("1","A");
            param.put("2","B");
            param.put("3","C");
            param.put("4","D");
            param.put("5","E");
            for (Map.Entry<String, String> p : param.entrySet()) {
                System.out.println("[ key=" + p.getKey() + " , " + p.getValue() + " ]");
            }
        }
    

    结果:
    [ key=1 , A ]
    [ key=2 , B ]
    [ key=3 , C ]
    [ key=4 , D ]
    [ key=5 , E ]

    方法二:使用Java8中map新增的方法forEach
    示例:

    public static void main(String[] args) {
            Map<String, String> param = new HashMap<>(8);
            param.put("1","A");
            param.put("2","B");
            param.put("3","C");
            param.put("4","D");
            param.put("5","E");
            param.forEach((key,value) -> System.out.println("[ key=" + key + " , " + value + " ]"));
        }
    

    结果:
    [ key=1 , A ]
    [ key=2 , B ]
    [ key=3 , C ]
    [ key=4 , D ]
    [ key=5 , E ]
    其实map新增的方法forEach底层实现与使用方法一的方法一致,源码解释:

    //map接口的默认方法,所有实现map的类都能调用
    default void forEach(BiConsumer<? super K, ? super V> action) {
    		//检查是否为null
            Objects.requireNonNull(action);
            for (Map.Entry<K, V> entry : entrySet()) {
                K k;
                V v;
                try {
                	//获取key-value
                    k = entry.getKey();
                    v = entry.getValue();
                } catch(IllegalStateException ise) {
                    throw new ConcurrentModificationException(ise);
                }
                //执行
                action.accept(k, v);
            }
        }
    
    展开全文
  • 遍历Map的几种方式

    万次阅读 2018-12-14 15:29:43
    遍历Map的几种方式 方法一 Person p1=new Person( 1,&amp;quot;what&amp;quot;); Person p2=new Person( 1,&amp;quot;张明&amp;quot;); Map&amp;amp;lt;Integer,Person&amp;amp;gt; map=...

    遍历Map的几种方式

    方法一

    Person p1=new Person( 1,"what");
    
    Person p2=new Person( 1,"张明");
    
    Map<Integer,Person> map=new HashMap<Integer, Person>();
    
    map.put( 1, p1);
    
    map.put( 2, p2);
    
             
    
    //遍历map集合
    
    for(Map.Entry<Integer, Person> a:map.entrySet()){
    
      System.out.println("键是"+a.getKey());
    
      System.out.println("值是"+a.getValue());
    
    }
    
    

    方法二

    Map map = newHashMap();
    
    map.put( 1, "Jacky");
    
    map.put( 2, "Lucy");
    
    map.put( 3, "Tom");
    
    Iterator it = map.entrySet().iterator();
    
    while(it.hasNext()){
    
    Map.Entry entry = (Map.Entry) it.next();
    
    System.out.println(entry.getKey() + " : " + entry.getValue());
    
    }
    

    方法三

    Iterator it=map.keySet().iterator();
    
    while(it.hasNext()){
    
     //取出key
    
     String key=it.next().toString();
    
     System.out.println(key);
    
     //通过key拿到value
    
     String str1=(String) map.get(key);
    
     System.out.println(str1);
    
    }
    
    
    展开全文
  • JAVA中遍历Map的四种方法-大容量Map迭代推荐

    万次阅读 多人点赞 2017-12-29 17:32:24
    Map(映射) 数组:几乎所有集合实现的底层都有数据的身影存在,因此我们首先需要了解一下数组。以下这段话摘自《Thinking In Algorithm》,感觉很不错现在拿出来跟大家分享。 《Thinking In Algorithm》之...

    前言

    java中的集合主要分为三种类型:

    • Set(集)

    • List(列表)

    • Map(映射)

    数组:几乎所有集合实现的底层都有数据的身影存在,因此我们首先需要了解一下数组。以下这段话摘自《Thinking In Algorithm》,感觉很不错现在拿出来跟大家分享。

    JAVA中遍历Map的四种方法-大容量Map迭代推荐

    《Thinking In Algorithm》之数组

    集合:接下来是集合,同样我们摘自网络上的一段解释,很不错也通俗易懂,与大家分享:

    JAVA中遍历Map的四种方法-大容量Map迭代推荐

    集合与数组

    总结一下上面两段话:

    数组的大小是固定不变的,并且同一个数组只能存储相同类型的数据,该数据类型可以是基本类型也可以是引用类型。Java中集合可以存储操作不同类型和大小不固定的数据,但是Java中集合只能存储引用类型,不能存储基本类型。


    Map遍历的代码示例

    一、数据准备

    JAVA中遍历Map的四种方法-大容量Map迭代推荐

    Map数据准备

    二、迭代示例

    1.第一种方式

    JAVA中遍历Map的四种方法-大容量Map迭代推荐

    二次取值方式

    2.第二种方式

    JAVA中遍历Map的四种方法-大容量Map迭代推荐

    Iterator遍历

    3.第三种方式

    JAVA中遍历Map的四种方法-大容量Map迭代推荐

    entrySet遍历

    4.第四种方式

    JAVA中遍历Map的四种方法-大容量Map迭代推荐

    Map.values取值遍历

    三、结果展示及总结

    JAVA中遍历Map的四种方法-大容量Map迭代推荐

    不同长度Map迭代结果

    结论:

    一般来讲使用entrySet的方式进行遍历是效率最高的,因为hashMap内部的存储结构就是基于Entry的数组,在用这种方式进行遍历时,只需要遍历一次即可。而使用其他方式的时间复杂度可以会提高,例如:keySet方式,每次都需要通过key值去计算对应的hash,然后再通过hash获取对应的结果值,因此效率较低。

    最后谢谢各位看官阅读本篇文章,希望大家可以关注本头条号,以便获取最新的技术咨询,也欢迎大家私信告诉我想了解的技术细节,我将给出对应的解读。


    头条号:程序猿的花果山。


    以下内容转发自博客:https://www.cnblogs.com/zhaoguhong/p/7074597.html?utm_source=itdadao&utm_medium=referral


    谈谈java中遍历Map的几种方法

    java中的map遍历有多种方法,从最早的Iterator,到java5支持的foreach,再到java8 Lambda,让我们一起来看下具体的用法以及各自的优缺点

    先初始化一个map

    public class TestMap {
      public static Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    }

    keySet values

    如果只需要map的key或者value,用map的keySet或values方法无疑是最方便的

      // KeySet 获取key
      public void testKeySet() {
        for (Integer key : map.keySet()) {
          System.out.println(key);
        }
      }
      // values 获取value
      public void testValues() {
        for (Integer value : map.values()) {
          System.out.println(value);
        }
      }

    keySet get(key)

    如果需要同时获取key和value,可以先获取key,然后再通过map的get(key)获取value

    需要说明的是,该方法不是最优选择,一般不推荐使用

      // keySet get(key) 获取key and value
      public void testKeySetAndGetKey() {
        for (Integer key : map.keySet()) {
          System.out.println(key + ":" + map.get(key));
        }
      }

    entrySet

    通过对map entrySet的遍历,也可以同时拿到key和value,一般情况下,性能上要优于上一种,这一种也是最常用的遍历方法

      // entrySet 获取key and value
      public void testEntry() {
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
          System.out.println(entry.getKey() + ":" + entry.getValue());
        }
      }

    Iterator

    对于上面的几种foreach都可以用Iterator代替,其实foreach在java5中才被支持,foreach的写法看起来更简洁

    但Iterator也有其优势:在用foreach遍历map时,如果改变其大小,会报错,但如果只是删除元素,可以使用Iterator的remove方法删除元素

      // Iterator entrySet 获取key and value
      public void testIterator() {
        Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator();
        while (it.hasNext()) {
          Map.Entry<Integer, Integer> entry = it.next();
          System.out.println(entry.getKey() + ":" + entry.getValue());
          // it.remove(); 删除元素
        }
      }

    Lambda

    java8提供了Lambda表达式支持,语法看起来更简洁,可以同时拿到key和value,不过,经测试,性能低于entrySet,所以更推荐用entrySet的方式

      // Lambda 获取key and value
      public void testLambda() {
        map.forEach((key, value) -> {
          System.out.println(key + ":" + value);
        });
      }

    简单性能测试

    用10万条数据,做了一个简单性能测试,数据类型为Integer,map实现选取HashMap

      static {
        for (int i = 0; i < 100000; i++) {
          map.put(i, 1);
        }
      }

    测试结果如下:

    KeySet:           392
    Values:           320
    keySet get(key)552
    entrySet:         465
    entrySet Iterator:508
    Lambda:           536

    需要说明的是,map存储的数据类型,map的大小,以及map的不同实现方式都会影响遍历的性能,所以该测试结果仅供参考

    总结

    如果只是获取key,或者value,推荐使用keySet或者values方式

    如果同时需要key和value推荐使用entrySet

    如果需要在遍历过程中删除元素推荐使用Iterator

    如果需要在遍历过程中增加元素,可以新建一个临时map存放新增的元素,等遍历完毕,再把临时map放到原来的map中


    展开全文
  • Map集合循环遍历的几种方式

    万次阅读 多人点赞 2018-11-15 16:29:23
    import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry;... * Map 集合的循环遍历  * @data 2018.1.21  *  */ public class TestMap {  ...
  • Map集合的五种遍历方式及Treemap方法

    万次阅读 2019-02-28 13:29:07
    //循环遍历map的方法 public class MapF { public static void main(String[] args) { Map&amp;lt;String, Integer&amp;gt; tempMap = new HashMap&amp;lt;String, Integer&amp;gt;(); tempMap....
  • 遍历Map的两种方式

    千次阅读 2019-05-30 17:01:39
    import java.util.HashMap;...import java.util.Map; import java.util.Set; public class Test { public static void main(String[] args) { Map&lt;String, String&gt; map = new HashMap&lt;S...
  • 遍历map的四种方法及Map.entry详解

    万次阅读 多人点赞 2018-08-27 10:25:29
    Map.entrySet() 这个方法返回的是一个Set&lt;Map.Entry&lt;K,V&gt;&gt;,Map.Entry 是Map中的一个接口,他的用途是表示一个映射项(里面有Key和Value),而Set&lt;Map.Entry&lt;K,V&gt;...
  • Map遍历几种方式

    千次阅读 2018-08-06 10:29:59
    Map&lt;String,String&gt;map=new HashMap&lt;&gt;(); map.put("name","li"); map.put("age","24"); // 第一种 for (String key:map.keySet()){ ...
  • 遍历map

    千次阅读 2018-10-09 08:57:01
    遍历map的常用方式一:键值都要 Map&lt;Integer, Integer&gt; map = new HashMap&lt;Integer, Integer&gt;(); for (Map.Entry&lt;Integer, Integer&gt; entry : map.entrySet()) { ...
  • C++ map遍历

    万次阅读 多人点赞 2017-09-23 08:36:21
    C++ map遍历#include #include <map>using namespace std;int main() { map, int> _map; _map[0] = 1; _map[1] = 2; _map[10] = 10; map, int>::iterator iter; iter = _map
  • 参考文章:https://blog.csdn.net/BillCYJ/article/details/78985895
  • js中遍历Map对象

    万次阅读 2013-10-09 14:51:56
    console.log(jsonData);//火狐控制台打印输出: Object { fileNumber="文件编号", fileName="文件名称"} for(var s in jsonData) console.log("属性:" + s + ",值:"+ jsonData[s]); } 打印输出: ...
  • Javascript遍历map集合以及map对象

    万次阅读 2017-07-22 00:14:21
    遍历map的时候发现了,map对象和map集合的遍历是有很大的不同。map集合是无序的,并且主键是唯一的。集合中的键和值可以是任何类型。如果使用现有密钥向集合添加值,则新值会替换旧值。 遍历map对象 var map = [{...
  • C++中map遍历的代码

    万次阅读 2019-02-02 14:31:01
    正确写法是: std::map&lt;int, TaskInfo*&gt; maps; //以下循环是错误的.因为KEY不是顺序号 //for(int i=0; i&lt;maps.size();... //正确遍历: std::map&lt;int, TaskInfo*...
  • java遍历Map效率最高的方式

    万次阅读 2017-11-30 15:10:32
    遍历Map的方式有很多,通常场景下我们需要的是遍历Map中的Key和Value,那么推荐使用的、效率最高的方式是:public static void main(String args...) { HashMap, String> hm = new HashMap, String>(); hm.put(...
  • vue使用v-for遍历Map对象

    万次阅读 2019-07-07 11:12:52
    遍历方式如下: v-for="(value, key) in mapObject" :key="key" 其中key为键,value为对应的值
  • C++中map遍历的两种方式

    万次阅读 2017-04-26 13:56:23
    C++中map遍历的两种方式
  • C++ map遍历(简单易记忆)

    万次阅读 多人点赞 2020-10-17 17:46:03
    C++中map遍历有两种方法:第一种,使用迭代器,while循环#include &lt;iostream&gt; #include &lt;map&gt; using namespace std; int main() { map&lt;int,int&gt; p; p[0] = 1; p[1] = ...
  • js遍历map对象

    万次阅读 2018-09-28 17:04:23
    直接先看实际案例。 当请求得到的数据不是json对象,而是map对象如理方式如下:   var map = result.data.map; var infoText = "共有"; var i = 0; ...
1 2 3 4 5 ... 20
收藏数 368,458
精华内容 147,383
关键字:

遍历map