精华内容
下载资源
问答
  • Map<String, Integer> myHashMap = new IdentityHashMap<>();//IdentityHashMap类型可以put相同key myHashMap.put("1", 1); myHashMap.put("21", 21); myHashMap.put("31", 41); myHashMap.put...
    Map<String, Integer> myHashMap = new IdentityHashMap<>();//IdentityHashMap类型可以put相同key
    		myHashMap.put("1", 1);
    		myHashMap.put("21", 21);
    		myHashMap.put("31", 41);
    		myHashMap.put("51", 51);
    		Iterator<Map.Entry<String, Integer>> entries = myHashMap.entrySet().iterator();
    		while (entries.hasNext()) {
    			Map.Entry<String, Integer> entry = entries.next();
    			System.out.println("遍历的结果" + entry.getKey() + ":" + entry.getValue());
    			//移除map中value值为1的键值对
    			if (entry.getValue() == 1) {
    				System.out.println("22222222222");
    				entries.remove();
    			}
    		}
    		//打印移除后的map内容
    		for (Map.Entry<String, Integer> entry1 : myHashMap.entrySet()) {
    			System.out.println("key:" + entry1.getKey() + " value:" + entry1.getValue());
    
    		}
    	}
    
    展开全文
  • 1. 使用Iterator迭代器遍历List、Set、Map import java.util.*; public class IteratorTest { public static void main(String[] args) { iteratorList(); iteratorSet(); iteratorMap(); } /** * 通过迭代...

    使用Iterator迭代器遍历

    1. 使用Iterator迭代器遍历List、Set、Map

    import java.util.*;
    
    public class IteratorTest {
        public static void main(String[] args) {
            iteratorList();
            iteratorSet();
            iteratorMap();
        }
    
        /**
         * 通过迭代器Iterator遍历list
         */
        public static void iteratorList(){
            List<String> list = new ArrayList<String>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            list.add("e");
    
            for(Iterator iterator = list.iterator();iterator.hasNext(); ){
                String s = (String) iterator.next();
                System.out.println(s);
            }
        }
    
        /**
         * 通过迭代器Iterator遍历Set
         */
        public static void iteratorSet(){
            Set<String> set = new HashSet<>();
            set.add("aa");
            set.add("bb");
            set.add("cc");
            set.add("dd");
            set.add("ee");
    
            for(Iterator iterator = set.iterator();iterator.hasNext(); ){
                String s = (String) iterator.next();
                System.out.println(s);
            }
        }
    	/**
         * 通过迭代器Iterator遍历Map
         */
        public static void iteratorMap(){
            Map<Integer, String> map = new HashMap<>();
            map.put(1001,"Ano");
            map.put(1002,"Jack");
            map.put(1003,"Charlie");
            Set<Integer> keys = map.keySet();
    
            for(Iterator iterator = keys.iterator();iterator.hasNext();){
                Integer integer = (Integer) iterator.next();
                String value = map.get(integer);
                System.out.println(integer +" =" +value);
            }
        }
    }
    

    2. 遍历容器方法汇总

    import java.util.List;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    import java.util.Map.Entry;
    
    public class TestThroughCollection {
        /**
         * 遍历list
         * @param list
         * @param <E>
         */
        public static <E> void throughList(List<E> list){
            //1.普通for循环
            for(int i =0; i < list.size(); i++){
                E e = list.get(i);
                System.out.println(e);
            }
    
            //2.增强for循环
            for(E e : list){
                System.out.println(e);
            }
    
            //3.使用Iterator迭代器(1)
            for(Iterator iterator = list.iterator(); iterator.hasNext();){
                E e = (E)iterator.next();
                System.out.println(e);
            }
    
            //4.使用Iterator迭代器(2)
            Iterator it = list.iterator();
            while(it.hasNext()){
                E e = (E)it.next();
                System.out.println(e);
            }
        }
    
        /**
         * 遍历Set
         * @param set
         * @param <E>
         */
        public static <E> void throughSet(Set<E> set){
            //1.增强for循环
            for(E e : set){
                System.out.println(e);
            }
    
            //2.Iterator迭代器
            for(Iterator iterator = set.iterator(); iterator.hasNext();){
                E e = (E)iterator.next();
                System.out.println(e);
            }
    
        }
    
        /**
         * 遍历Map
         * @param map
         * @param <K>
         * @param <V>
         */
        public static <K, V> void throughMap(Map<K, V> map){
            //1.根据Key获取value
            Set<K> set = map.keySet();
            for(Iterator it = set.iterator(); it.hasNext();){
                K key = (K)it.next();
                V value = map.get(key);
            }
    
            //2.使用entrySet
            Set<Entry<K,V>> ss = map.entrySet();
            //2.1
            for(Entry<K,V> entry : ss){
                System.out.println(entry);
            }
            //2.2
            /*
            for(Iterator it = ss.iterator(); it.hasNext();){
                Entry<K, V> entry = (Entry<K, V>) it.next();
                System.out.println(entry);
                System.out.println(entry.getKey() + "=" + entry.getValue());
            }
             */
        }
    }
    
    展开全文
  • C++ STL map容器迭代器遍历 标准库为 map 容器配备的是双向迭代器(bidirectional iterator)。这意味着,map 容器迭代器只能进行 ++p、p++、–p、p–、*p 操作,并且迭代器之间只能使用 == 或者 != 运算符进行比较...

    C++ STL map容器迭代器遍历

    标准库为 map 容器配备的是双向迭代器(bidirectional iterator)。这意味着,map 容器迭代器只能进行 ++p、p++、–p、p–、*p 操作,并且迭代器之间只能使用 == 或者 != 运算符进行比较。

    值得一提的是,相比序列式容器,map 容器提供了更多的成员方法(如表 1 所示),通过调用它们,我们可以轻松获取具有指定含义的迭代器。

    成员方法 功能
    begin() 返回指向容器中第一个(注意,是已排好序的第一个)键值对的双向迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    end() 返回指向容器最后一个元素(注意,是已排好序的最后一个)所在位置后一个位置的双向迭代器,通常和 begin() 结合使用。如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    rbegin() 返回指向最后一个(注意,是已排好序的最后一个)元素的反向双向迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。
    rend() 返回指向第一个(注意,是已排好序的第一个)元素所在位置前一个位置的反向双向迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。
    cbegin() 和 begin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。
    cend() 和 end() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。
    crbegin() 和 rbegin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。
    crend() 和 rend() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。
    find(key) 在 map 容器中查找键为 key 的键值对,如果成功找到,则返回指向该键值对的双向迭代器;反之,则返回和 end() 方法一样的迭代器。另外,如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    lower_bound(key) 返回一个指向当前 map 容器中第一个大于或等于 key 的键值对的双向迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    upper_bound(key) 返回一个指向当前 map 容器中第一个大于 key 的键值对的迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    equal_range(key) 该方法返回一个 pair 对象(包含 2 个双向迭代器),其中 pair.first 和 lower_bound() 方法的返回值等价,pair.second 和 upper_bound() 方法的返回值等价。也就是说,该方法将返回一个范围,该范围中包含的键为 key 的键值对(map 容器键值对唯一,因此该范围最多包含一个键值对)。

    表 1 中多数的成员方法,诸如 begin()、end() 等,在学习序列式容器时已经多次使用过,它们的功能如图 2 所示。

    C++ STL map部分成员方法示意图

    遍历
        std::map<std::string, std::string>myMap;
       //调用 begin()/end() 组合,遍历 map 容器
        for (auto iter = myMap.begin(); iter != myMap.end(); ++iter) {
            cout << iter->first << " " << iter->second << endl;//此处用的是迭代器来查找的key和value;
        }
    

    此处用的是迭代器来查找的key和value;
    }

    反向遍历:

    此处比较陌生,但容易碰到,(rbegin(),rend())

     for (auto iter = myMap.rbegin(); iter != myMap.rend(); --iter) {
            cout << iter->first << " " << iter->second << endl;//此处用的是迭代器来查找的key和value;
        }
    
    展开全文
  • C++ map迭代器遍历

    万次阅读 2018-12-14 16:24:11
    map&lt;string,int&gt; m; map&lt;string,int&gt;::iterator it; it = m.begin(); while(it != m.end()) { it-&gt;first; it-&gt;second; it ++; }

    map<string,int> m;

    map<string,int>::iterator it;

    it = m.begin();

    while(it != m.end())
    {
    it->first;
    it->second;
    it ++;
    }

    展开全文
  • map和set的迭代器遍历

    2020-06-05 11:45:46
    使用迭代器遍历 //Entry表示一个键值对 //EntrySet包含Entry的Set Iterator<Map.Entry<Integer,Integer>> iterator=map.entrySet().iterator(); while(iterator.hasNext()){ Map.Entry<Integer,...
  • 【Java后端】Map使用迭代器遍历

    万次阅读 2018-11-22 09:37:11
    map的entry可以通过迭代器进行遍历以及进行安全的remove操作。 private void removeExist(Map&amp;lt;Integer, String&amp;gt; types, DictTypeResDTO dto) { Iterator&amp;lt;Map.Entry&amp;lt;...
  • 使用迭代器 遍历ArrayList,遍历 Map

    千次阅读 2019-07-08 20:15:53
    一般遍历数组都是采用for循环或者增强for,这两个方法也可以用在集合框架,但是还有一种方法是采用迭代器遍历集合框架,它是一个对象,实现了Iterator接口或ListIterator接口。 迭代器,使你能够通过循环来得到或...
  • map 通过迭代器 遍历

    千次阅读 2015-03-18 15:16:30
    package com.test; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class MapIterator {  public static void main(String[] args){  
  • 迭代器遍历List Map Set

    2019-09-05 22:37:08
    迭代器遍历List Map Set package cn.dct.oop; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; ...
  • 迭代器遍历List Set Map

    2019-08-19 22:30:54
    迭代器遍历List Set Map - - package cn.sxt.collection; - - import java.util.ArrayList; - import java.util.HashMap; - import java.util.HashSet; - import java.util.Iterator; - import java.util.List; - ...
  • Map集合的增强for循环遍历和迭代器遍历 public static void main(String[] args) { Map<Integer,String> map = new HashMap<>(); map.put(111,"zs"); map.put(222,"ls"); map.put(333,"ww"); map....
  • import java.util.*; ... * 测试迭代器遍历List Set Map * */ public class TestIterator { public static void main(String[] args) { testIteratorList(); testIteratorSet(); testIte...
  • Map集合遍历迭代器 Map<Integer,Integer> coll01 = new HashMap<>(); coll01.put(12,21); coll01.put(32,23); coll01.put(43,34); coll01.put(45,54); //用Set keySet();方法获取键Key Set num01 = ...
  • C++用迭代器遍历map的key值方法 一般来说应用C++的map的时候,我们往往事先知道它有哪些key值,但偏偏有些问题我们实现并不知道。那么此时如何遍历出map的key值和val呢,那就只能用迭代器了,示例如下: map<int,...
  • 迭代器遍历map集合

    2020-07-23 09:36:14
    public static void main... Map map = new HashMap<String,String>(); map.put("01","11111"); map.put("02","22222"); map.put("03","3333"); Set<String> set = map.keySet(); Iterator&l..
  • Iterator迭代器 遍历Map

    2017-05-07 10:51:28
    迭代器
  • 使用Iterator迭代器遍历List、Set和Map基础知识代码结果 基础知识       所有集合类均未提供相应的遍历方法,而是把遍历交给迭代器完成。迭代器为集合而生,专门实现集合遍历。 1、...
  • Iterator迭代器遍历(List,Set,Map都通用) Iterator<Student> is=l.iterator(); while(is.hasNext()){ Student s=is.next(); System.out.println(s.getName()+"\t"+s.getAge()); } Map更常用的是通过Map...
  • java使用Iterator迭代器遍历容器元素(List/Set/Map) 开发工具与关键技术:java、 elipse2019、jdk1.8 作者:Amewin 撰写时间:2019年4月28日 迭代器遍历List public class Test { public static void main...
  • 迭代器遍历【List、Set、Map】 example 1 package boom.collection; 2 3 import java.util.ArrayList; 4 import java.util.HashMap; 5 import java.util.HashSet; 6 import java.util.Iterator; ...
  • 实例: 定义一个类: package JiHe.MapJiHe; import java.util.HashMap; import java.util.Iterator;...import java.util.Map;... Map集合遍历的第二种方式:使用Entry对象遍历 Map集合中的方法: Set<M...
  • import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator;...import java.util.List;...import java.util.Map;... * 测试迭代器遍历List,Set,Ma

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,101
精华内容 840
关键字:

map迭代器遍历