精华内容
下载资源
问答
  • c++迭代器iterator遍历map
    千次阅读
    2020-07-10 13:49:33
    #include<iostream>
    #include<map>
    #include<string>
    
    using namespace std;
    
    int main() {
    	map <string,int> month;
    	month["July"] = 7;
    	month["T"] = 1;
    	map<string,int>::iterator i;
    	for (i = month.begin();i!=month.end();i++) {
    		cout<<i->first<<i->second<<endl;
    	}
    	cout<<" "<<endl;
    	return 0;
    } 
    
    更多相关内容
  • 迭代器iterator遍历集合

    千次阅读 2022-05-25 11:28:08
    迭代器是将数据放在一个容器中,并排成一排,迭代器有一个游标,再未遍历之前,这个游标放在第一位元素的前面,一般是迭代器iterator.hasNext判断游标后面是否有元素,iterator.next是将游标向后移一位。 list集合...

    集合分为list、set和map。list排列有序,可重复;set排列无序,不可重复;map键不可重复,值可重复,排列无序。

    一般遍历用for循环,但是set和map无序,所以要用迭代器。

    迭代器是将数据放在一个容器中,并排成一排,迭代器有一个游标,再未遍历之前,这个游标放在第一位元素的前面,一般是迭代器iterator.hasNext判断游标后面是否有元素,iterator.next是将游标向后移一位。

    list集合分为ArrayList、vector、LinkedList
    ArrayList:排列有序,可重复,底层是数组,增删慢,查询快,扩容机制是当前容量的1.5倍+1,线程不安全。
    vector:排列有序,可重复,底层是数组,增删慢,查询快,扩容机制是当前容量的1倍,线程安全。vector因为是线程安全的,所以它的查询速度没有ArrayList快。
    LinkedList:排列有序,可重复,底层是链表,增删快,查询慢,线程不安全

    set集合分为HashSet、TreeSet和LinkedHshSet
    HashSet:排列无序,不可重复,存取速度快
    TreeSet:排列无序,不可重复,排序存储
    LinkedHashSet:排列无序,不可重复,一般不用

    map集合分为HashMap、TreeMap、hashtable
    HashMap:排序无序,键不可重复,值可重复,线程不安全,键值都可为null
    TreeMap:排列无序,键不可重复,值可重复
    hashtable:排列无序,键不可重复,值可重复,线程安全,键值都不可为null

    list迭代器遍历

    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("a");
    list.add("b");
    Iterator<String> iterator = list.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
    

    set迭代器遍历

    Set<String> set = new HashSet<>();
    set.add("a");
    set.add("a");
    set.add("b");
    Iterator<String> iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
    

    map迭代器遍历
    因为map里面存储的是键值对,如果要遍历的话,需要把map里的对象看成一个整体

    Map<Integer,String> map = new HashMap<>();
    map.put(1,"a");
    map.put(1,"b");
    map.put(2,"a");
    Set<Map.Entry<Integer, String>> set = map.entrySet();
    Iterator<Map.Entry<Integer, String>> iterator = set.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
    
    展开全文
  • C++ 迭代器 Iterator

    千次阅读 2022-03-03 13:20:34
    C++ 迭代器 Iterator

    C++ 迭代器(Iterator)

    1.1 定义

    • 迭代器是一种检查容器内元素并遍历元素的数据类型。
    • 迭代器是一个变量,提供对一个容器中的对象的(间接)访问方法,并且定义了容器中对象的范围
    • 迭代器可以指向容器中的某个元素,通过迭代器就可以对非数组(存储空间不连续)的数据结构进行遍历。
    • 容器和string有迭代器类型同时拥有返回迭代器的成员。如:容器有成员 begin 和 end ,其中begin成员复制返回指向第一个元素的迭代器,而end成员返回指向容器尾元素的下一个位置的迭代器,也就是说end指示的是一个不存在的元素,所以end返回的是尾后迭代器。
    iterator iter; 	// 声明迭代器iter
    
    for(iter = 容器.begin(); iter != 容器.end(); iter++){
    	cout << *iter 或者是 iter->first ;                                
    }
    

    1.2 迭代器种类

    1. 正向迭代器,定义方法如下:
      容器类名::iterator 迭代器名;
    2. 常量正向迭代器,定义方法如下:
      容器类名::const_iterator 迭代器名;
    3. 反向迭代器,定义方法如下:
      容器类名::reverse_iterator 迭代器名;
    4. 常量反向迭代器,定义方法如下:
      容器类名::const_reverse_iterator 迭代器名;

    1.3 迭代器的使用

    • 通过迭代器可以读取它指向的元素,*迭代器名就表示迭代器指向的元素。通过非常量迭代器还能修改其指向的元素。
    • 迭代器都可以进行++操作。反向迭代器和正向迭代器的区别在于:
      • 正向迭代器进行++操作时,迭代器会指向容器中的后一个元素; begin() -> end() 从前往后遍历
      • 反向迭代器进行++操作时,迭代器会指向容器中的前一个元素。 rbegin() -> rend() 从后往前遍历

    遍历vector容器的所有元素示例:

    #include <iostream>
    #include <vector>
    using namespace std;
    int main()
    {
        vector<int> v;
        for(int i = 0; i < 5; ++i){
            v.push_back(i);             // v = {0, 1, 2, 3, 4}
        }
    
        vector<int>::iterator iter;     // 正向迭代 begin -> end,输出 {0, 1, 2, 3, 4}
        for(iter = v.begin(); iter != v.end(); ++iter){
            cout << *iter << endl;
        }
    
        vector<int>::reverse_iterator riter;    // 反向迭代 rbegin -> rend,输出 {4, 3, 2, 1, 0}
        for(riter = v.rbegin(); riter != v.rend(); ++riter){
            cout << *riter << endl;
        }
        return 0}
    

    提示:
    后置++要多生成一个局部对象 tmp,因此执行速度比前置++的慢。同理,迭代器是一个对象,STL 在重载迭代器的++运算符时,后置形式也比前置形式慢。在次数很多的循环中,++i 和 i++ 可能就会造成运行时间上可观的差别了。对循环控制变量 i,要养成写++i、不写i++的习惯。

    1.4 迭代器的功能分类

    不同容器的迭代器,其功能强弱有所不同。容器的迭代器的功能强弱,决定了该容器是否支持 STL 中的某种算法。
    例如,排序算法需要通过随机访问迭代器来访问容器中的元素,因此有的容器就不支持排序算法。

    不同容器的迭代器功能:

    容器迭代器功能
    forward_list前向
    unordered_set / unordered_multiset前向
    unordered_map / unordered_multimap前向
    vector随机访问
    deque随机访问
    array随机访问
    list双向
    set / multiset双向
    map / multimap双向
    stack不支持迭代器
    queue不支持迭代器
    priority_queue不支持迭代器

    不同功能的迭代器说明:

    迭代器类别说明
    输入从容器中读取元素。输入迭代器只能一次读入一个元素向前移动,输入迭代器只支持一遍算法,同一个输入迭代器不能两次遍历一个序列
    输出向容器中写入元素。输出迭代器只能一次一个元素向前移动。输出迭代器只支持一遍算法,同一输出迭代器不能两次遍历一个序列
    正向组合输入迭代器和输出迭代器的功能,并保留在容器中的位置
    双向组合正向迭代器和逆向迭代器的功能,支持多遍算法
    随机访问组合双向迭代器的功能与直接访问容器中任何元素的功能,即可向前向后跳过任意个元素

    不同功能的迭代器操作:

    1. 输入:++pp++*pp1 = p2p1 == p2p1 != p2
    2. 输出:++pp++*pp1 = p2
    3. 正向迭代:++pp++*pp1 = p2p1 == p2p1 != p2
    4. 双向迭代:++pp++*pp1 = p2p1 == p2p1 != p2--pp--
    5. 随机访问:++pp++*pp1 = p2p1 == p2p1 != p2--pp--p+=ip-=ip+ip-ip1 < 、>、<=、>= p2p[i](返回 p 后面第 i 个元素的引用),p2-p1(返回 p2 所指向元素和 p1 所指向元素的序号之差)

    1.5 迭代器的辅助函数

    STL 中有用于操作迭代器的三个函数模板,它们是:

    • advance(p, n):使迭代器 p 向前或向后移动 n 个元素。
    • distance(p, q):计算两个迭代器之间的距离,即迭代器 p 经过多少次 + + 操作后和迭代器 q 相等。如果调用时 p 已经指向 q 的后面,则这个函数会陷入死循环。
    • iter_swap(p, q):用于交换两个迭代器 p、q 指向的值。

    参考:
    http://c.biancheng.net/view/338.html
    https://blog.csdn.net/CSDN_564174144/article/details/76231626

    1.6 迭代器的失效问题

    不能以指针来看待迭代器,指针是与内存绑定的,而迭代器是与容器里的元素绑定的,删除了之后,该迭代器就失效了,在对其重新赋值之前,不能再访问此迭代器。

    STL 迭代器失效的几种情况总结
    C++容器类插入和删除时迭代器的失效情况总结

    • 序列式(数组式) 容器
      • vector 迭代器失效
        (1)erase() 和 insert() 会使当前位置到容器末尾元素的迭代器全部失效 ;这是因为vetor,deque使用了连续分配的内存,删除一个元素导致后面所有的元素会向前移动一个位置,此时 iter 已经指向的是未知内存;解决方法是利用 erase方法可以返回下一个有效的 iterator
        (2)扩容时,所有迭代器都会失效。
      • deque 迭代器失效
        (1)插入到除首尾位置之外的任何位置都会导致迭代器、指针和引用都会失效,但是如果在首尾位置添加元素,迭代器会失效,但是指针和引用不会失效;
        (2)如果在首尾之外的任何位置删除元素,那么指向被删除元素外其他元素的迭代器全部失效;
        (3)在其首部或尾部删除元素则只会使指向被删除元素的迭代器失效。

    • 节点式容器:
      • 关联式容器(如map, set,multimap,multiset)
        (1)删除当前的iterator,仅仅会使当前的iterator失效,只要在erase 时,递增当前 iterator erase(iter++)或者 利用 erase 返回的有效迭代器 iter = cont.erase(iter);进行操作即可;
        (2)插入不会使得任何迭代器失效。
        这是因为map之类的容器,使用了红黑树来实现,插入、删除一个结点不会对其他结点造成影响。
      • 链表式容器(如list)
        (1)删除当前的iterator,仅仅会使当前的iterator失效,只要在erase 时,递增当前 iterator erase(iter++)或者 利用 erase 返回的有效迭代器 iter = cont.erase(iter);进行操作即可;
        (2)插入不会使得任何迭代器失效。
        这是因为list之类的容器,使用了链表来实现,插入、删除一个结点不会对其他结点造成影响。

    • 哈希容器unordered_map, unordered_multimap, unordered_multiset, unordered_set):
      (1)删除当前的iterator,仅仅会使当前的iterator失效,只要在erase 时,递增当前 iterator erase(iter++)或者 利用 erase 返回的有效迭代器 iter = cont.erase(iter);进行操作即可;
      (2)插入不会使得任何迭代器失效。
      这是因为这些容器使用了哈希表来实现,插入、删除一个结点不会对其他结点造成影响。
    展开全文
  • Iterator遍历迭代Map集合的三种方式

    千次阅读 2022-03-19 09:42:37
    使用Iterator遍历迭代Map集合的三种方式

     Map集合有5种遍历方式 详细见我上篇关于Map集合的文章

    其中的Iterator遍历如下

    package demo3;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map.Entry;
    
    public class TestIterator {
    	public static void main(String[] args) {
    		//创建对象
    		Student stu1=new Student();
    		Student stu2=new Student();
    		Student stu3=new Student();
    		
    		//创建集合
    		HashMap<Integer,Student> Map=new HashMap<Integer,Student>();
    		
    		//把对象放入集合
    		Map.put(1, stu1);
    		Map.put(2, stu2);
    		Map.put(3, stu3);
    		
    		
    		System.out.println("******** 第一种迭代keyset ********");
    		
    		Iterator<Integer> it=Map.keySet().iterator();
    		while(it.hasNext()) {
    			
    			Integer key=it.next();
    			Student value=Map.get(key);
    			System.out.println("键值对是--"+key+"---"+value);
    		}
    		System.out.println("******** 第二种迭代values ********");
    		
    		Iterator<Student> it1=Map.values().iterator();
    		while(it1.hasNext()) {
    			
    			Student value=it1.next();
    			
    			System.out.println("键值对是--"+"---"+value);
    		}
    		System.out.println("******** 第三种迭代entrySet ********");
    		
    		Iterator<Entry<Integer,Student>> it2=Map.entrySet().iterator();
    		while(it2.hasNext()) {
    			
    			Entry<Integer,Student> entry=it2.next();
    			Integer key=entry.getKey();
    			Student value=entry.getValue();
    			
    			System.out.println("键值对是--"+key+"---"+value);
    		}
    		
    	}
    }
    

     

    学生类 

    package demo3;
    
    
    
    public class Student {
    	  private long id;
    	  private String name;
    	  private long age;
    	  private String sex;
    	  private String pwd;
    	  private long tid;
    	  private long version;
    
    
    	  public long getId() {
    	    return id;
    	  }
    
    	  public void setId(long id) {
    	    this.id = id;
    	  }
    
    
    	  public String getName() {
    	    return name;
    	  }
    
    	  public void setName(String name) {
    	    this.name = name;
    	  }
    
    
    	  public long getAge() {
    	    return age;
    	  }
    
    	  public void setAge(long age) {
    	    this.age = age;
    	  }
    
    
    	  public String getSex() {
    	    return sex;
    	  }
    
    	  public void setSex(String sex) {
    	    this.sex = sex;
    	  }
    
    
    	  public String getPwd() {
    	    return pwd;
    	  }
    
    	  public void setPwd(String pwd) {
    	    this.pwd = pwd;
    	  }
    
    
    	  public long getTid() {
    	    return tid;
    	  }
    
    	  public void setTid(long tid) {
    	    this.tid = tid;
    	  }
    
    
    	  public long getVersion() {
    	    return version;
    	  }
    
    	  public void setVersion(long version) {
    	    this.version = version;
    	  }
    
    	@Override
    	public String toString() {
    		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", pwd=" + pwd + ", tid="
    				+ tid + ", version=" + version + "]";
    	}
    
    	public Student(long id, String name, long age, String sex, String pwd, long tid, long version) {
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    		this.sex = sex;
    		this.pwd = pwd;
    		this.tid = tid;
    		this.version = version;
    	}
    
    	public Student() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	  
    
    }
    

     

     

     第三种迭代解析

    map不有个Key和value吗 一个Key对应一个value 而key和value组合起来的一个组就是entry 要想取出这个组里的key和value就用entry的迭代器迭代即可。

    //获得map的迭代器,用作遍历map中的每一个键值对
    Iterator是迭代器,map之前应该定义过,姑且认为是HashMap。
    <Entry<String,String>>表示map中的键值对都是String类型的。
    map.entrySet()是把HashMap类型的数据转换成集合类型
    map.entrySet().iterator()是去获得这个集合的迭代器,保存在iter里面。。
    迭代器这么用:
    while(iter.hasNext()) {
    Entry<> obj = it.next();//就能获得map中的每一个键值对了
    }

    Iterator<Entry<String,String>> iter=map.entrySet().iterator();

    按正常思路来写怎样写?
    (调用entrySet()和iterator()不是分开写的吗?
    为什么Entry的首字母要大写?

    这留给聪明的你仔细想想!!!!

    以上就是三种迭代的使用啦!!!!!

    展开全文
  • C++迭代器遍历map的key值方法

    千次阅读 2020-11-20 11:04:01
    C++迭代器遍历map的key值方法 一般来说应用C++的map的时候,我们往往事先知道它有哪些key值,但偏偏有些问题我们实现并不知道。那么此时如何遍历出map的key值和val呢,那就只能用迭代器了,示例如下: map<int,...
  • C++迭代器iterator

    千次阅读 多人点赞 2021-07-30 16:54:10
    C++更趋向于使用迭代器而不是数组下标操作,因为标准库为每一种标准容器(如vector、map和list等)定义了一种迭代器类型,而只有少数容器(如vector)支持数组下标操作访问容器元素。可以通过迭代器指向你想访问容器...
  • C++ STL map容器迭代器遍历

    千次阅读 2021-02-26 22:51:51
    C++ STL map容器迭代器遍历 标准库为 map 容器配备的是双向迭代器(bidirectional iterator)。这意味着,map 容器迭代器只能进行 ++p、p++、–p、p–、*p 操作,并且迭代器之间只能使用 == 或者 != 运算符进行比较...
  • 正向迭代器:vector::iterator 迭代器变量名 反向迭代器:vector::reverse_iterator 迭代器变量名 :在不知道所包含数据个数的情况下用以遍历元素 vector<int> v; //v是存放int类型变量的可变长数组,开始时...
  • c++mapiterator用法

    2022-04-29 20:25:06
    资料一:http://www.cplusplus.com/reference/iterator/(第一参考,简单精要) 资料二:http://jjhou.boolan.com/programmer-3-traits.pdf(侯捷随笔,非常全面,有时间深刻可看) 资料三:...
  • Iterator迭代器)是一个接口,它的作用就是遍历容器的所有元素,也是 Java 集合框架的成员,但它与 Collection 和 Map 系列的集合不一样,Collection 和 Map 系列集合主要用于盛装其他对象,而 Iterator 则主要...
  • 要访问顺序容器和关联容器中的元素,需要通过“迭代器iterator)”进行。迭代器是一个变量,相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素,通过迭代器就可以读写它指向的元素。从这一点...
  • C++map遍历

    2022-04-29 20:34:00
    map反向迭代器的使用实战 1代码 #include <map> #include <string> #include <iostream> using namespace std; int main(){ map<int,string> mapStudent; mapStudent[1] = "student_one...
  • 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 ++; }
  • iterator erase( const_iterator Where); iterator erase( const_iterator First, const_iterator Last); size_type erase( const key_type&...由于map只支持erase(const_iterator)或erase(co...
  • C++为了方便统一,采用了设计模式中的迭代器模式,也就是统一的提供了一种方法顺序访问一个聚合对象中的各种元素,而又不暴露该对象的内部表示。我们一般对这些数据结构的遍历都可以无脑使用迭代器,而不关心内部...
  • C++ 迭代器iterator的实现原理

    千次阅读 多人点赞 2020-01-03 09:31:03
    文章目录C++ 迭代器iterator的实现原理1. list类1.1 ListItem1.2 list类2. iterator3. 使用4. 总结 C++ 迭代器iterator的实现原理 在经典的设计模式中,有一种迭代器模式,定义为:提供一个对象来顺序访问聚合对象中...
  • C++迭代器iterator)用法

    千次阅读 2022-02-17 16:06:59
    c++迭代器用法
  • 积压订单中的订单总数》 时用到了map的反向遍历,看到问题时首先想到了优先队列,但是需要维护一个大根堆和一个小根堆,感觉操作起来比较麻烦,突发奇想使用map就能够解决。map本身就是有序的,正向遍历可以得到...
  • 迭代器iterator)是一种对象,它能够用来遍历标准模板库容器中的部分或全部元素,每个迭代器对象代表容器中的确定的地址,简单点就是每个“节点”对象的“指针”。但如果对迭代器在不同类型的容器中使用的方法不够...
  • C++迭代器反向遍历

    千次阅读 2020-03-24 19:28:13
    map<int, string>::reverse_iterator iter; for (iter = mouse.rbegin(); iter!=mouse.rend(); iter++) { cout<<iter->second << endl; }
  • int main() { map, int64_t> mp({{1, 2}, {3, 5}, {2, 7}}); for (auto rItr = mp.rbegin(); rItr != mp.rend(); ) { if (rItr->first == 3) { mp.erase((++rItr).base()); } else { rItr++; } } return 0; }
  • C++ 中,严格来说,bitset并不属于stl容器的范畴,它也不支持指示的操作。bitset提供了对数据的位操作。 bit set 压位 即如其名,bit set储存的是二进制。 它是一种类似数组的结构,它的每一个元素只能是0或1...
  • C++ 迭代器(iterator)超详解+实例演练

    千次阅读 多人点赞 2021-10-30 11:22:39
    C++ STL 迭代器详解一级目录二级目录三级目录 一级目录 二级目录 三级目录
  • map迭代器进行遍历的方法总结

    万次阅读 2016-12-01 21:33:35
    注意:不能直接拿map的key值作为迭代器进行遍历public static void main(String[] args) { Map, String> map = new HashMap, String>(); map.put("1", "value1"); map.put("2", "value2"); map.put("3", "value3...
  • C++遍历map方法

    千次阅读 2022-04-29 20:46:52
    C++遍历map方法 C++中访问容器需要使用迭代器,而非下标。 c++98 map<string, int>::iterator it; for (it = m2.begin(); it != m2.end(); it++) { string s = it->first; printf("%s %d ", s.data(), ...
  • std::map<int, int> test; test[1] = 10; test[2] = 20; map <int, int>::iterator it = test.begin(); map <int, int>::reverse_iterator rit = test.rbegin(); for (;r...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,408
精华内容 8,563
热门标签
关键字:

c++迭代器iterator遍历map

c++ 订阅