精华内容
下载资源
问答
  • javaiterator迭代器详解
    千次阅读
    2021-02-17 11:31:27

    目录

    一、Java中Iterator迭代器详解

    1、为什么需要迭代器

    2、迭代器长什么样子

    3、如何使用迭代器

    使用步骤:

    代码演示:

    迭代器可以简化为增强型for循环:

    4、Iterator与ListIterator有什么区别


    一、Java中Iterator迭代器详解

    1、为什么需要迭代器

    Java中的集合各式各样,很多应用场景下需要对集合里面的元素进行遍历,有的集合有下标(ArrayList、Vector、LinkedList),有的集合没有下标。有下标的集合可以轻易地通过下标进行遍历,没有下标的集合遍历起来就非常麻烦,因此Java引入了迭代器模式迭代器可以使得我们能够使用一种通用的方式遍历各种集合元素

     

    2、迭代器长什么样子

    // 迭代器主要提供下面这三个方法
    public interface Iterator<E> {
        // 是否有下一个元素
        boolean hasNext();
        // 获取下一个元素
        E next();
        // 删除元素
        void remove();
    }

     

    3、如何使用迭代器

    使用步骤:

    • 获取迭代器;

    • 判断是否存在下一个元素;

    • 获取下一个元素;

     

    代码演示:

    package com.zibo.java.february.third;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class MyListStudy {
        public static void main(String[] args) {
            // 创建一个list
            List<String> list = new ArrayList<>();
            list.add("大哥");
            list.add("二哥");
            list.add("三哥");
            list.add("四哥");
            // 获取迭代器;
            Iterator<String> iterator = list.iterator();
            // 判断是否存在下一个元素;
            while (iterator.hasNext()){
                // 获取下一个元素;
                System.out.println(iterator.next());
            }
        }
    }

     

    迭代器可以简化为增强型for循环:

    package com.zibo.java.february.third;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class MyListStudy {
        public static void main(String[] args) {
            // 创建一个list
            List<String> list = new ArrayList<>();
            list.add("大哥");
            list.add("二哥");
            list.add("三哥");
            list.add("四哥");
            // 获取迭代器;
            // 判断是否存在下一个元素;
            for (String s : list) {
                // 获取下一个元素;
                System.out.println(s);
            }
            // 增强型for循环内部使用的就是迭代器
        }
    }

     

    4、Iterator与ListIterator有什么区别

    Iterator只能正向遍历集合,适用于获取移除元素。ListIerator继承自Iterator,专门针对List,可以从两个方向遍历List,同时支持元素的修改;

     

     

     

     

     

     

     

     

     

     

    更多相关内容
  • Java中的Iterator迭代器详解

    千次阅读 2022-04-18 12:49:50
    Iterator接口也是Java集合中的一员,但它与Collection、Map接口有所不同,Collection接口与Map接口主要用于存储元素,而Iterator主要用于迭代访问(即遍历)Collection中的元素,因此Iterator对象也被称为迭代器。...

    🍦Iterator接口

    在程序开发中,经常需要遍历集合中的所有元素。针对这种需求,JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员,但它与Collection、Map接口有所不同,Collection接口与Map接口主要用于存储元素,而Iterator主要用于迭代访问(即遍历)Collection中的元素,因此Iterator对象也被称为迭代器。
    想要遍历Collection集合,那么就要获取该集合迭代器完成迭代操作,下面介绍一下获取迭代器的方法:

    • public Iterator iterator(): 获取集合对应的迭代器,用来遍历集合中的元素的。

    下面介绍一下迭代的概念:

    • 迭代:即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

    Iterator接口的常用方法如下:

    • public E next():返回迭代的下一个元素。
    • public boolean hasNext():如果仍有元素可以迭代,则返回 true。

    接下来我们通过案例学习如何使用Iterator迭代集合中元素:

    public class IteratorDemo {
        public static void main(String[] args) {
            // 使用多态方式 创建对象
            Collection<String> coll = new ArrayList<String>();
    
            // 添加元素到集合
            coll.add("张三");
            coll.add("李四");
            coll.add("王五");
            //遍历
            //使用迭代器 遍历   每个集合对象都有自己的迭代器
            Iterator<String> it = coll.iterator();
            //  泛型指的是 迭代出 元素的数据类型
            while(it.hasNext()){ //判断是否有迭代元素
                String s = it.next();//获取迭代出的元素
                System.out.println(s);
            }
        }
    }
    

    💡tips::在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发生java.util.NoSuchElementException没有集合元素的错误。

    🍧迭代器的实现原理

    我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时,首先通过调用t集合的iterator()方法获得迭代器对象,然后使用hashNext()方法判断集合中是否存在下一个元素,如果存在,则调用next()方法将元素取出,否则说明已到达了集合末尾,停止遍历元素。
    Iterator迭代器对象在遍历集合时,内部采用指针的方式来跟踪集合中的元素,为了让初学者能更好地理解迭代器的工作原理,接下来通过一个图例来演示Iterator对象迭代元素的过程:在这里插入图片描述
    在调用Iterator的next方法之前,迭代器的索引位于第一个元素之前,不指向任何元素,当第一次调用迭代器的next方法后,迭代器的索引会向后移动一位,指向第一个元素并将该元素返回,当再次调用next方法时,迭代器的索引会指向第二个元素并将该元素返回,依此类推,直到hasNext方法返回false,表示到达了集合的末尾,终止对元素的遍历。

    🍨增强for

    增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。
    格式:

    for(元素的数据类型 变量 : Collection集合or数组){
    //写操作代码
    }

    它用于遍历Collection和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。

    🍩练习1:遍历数组

    public class NBForDemo1 {
        public static void main(String[] args) {
            int[] arr = {3,5,6,87};
            //使用增强for遍历数组
            for(int a : arr){//a代表数组中的每个元素
                System.out.println(a);
            }
        }
    }
    

    🍪练习2:遍历集合

    public class NBFor {
        public static void main(String[] args) {        
            Collection<String> coll = new ArrayList<String>();
            coll.add("张三");
            coll.add("李四");
            coll.add("王五");
            //使用增强for遍历
            for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
                System.out.println(s);
            }
        }
    }
    

    💡tips: 新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。

    展开全文
  • 为什么要迭代器? 我们知道,对于集合来说,有的有下标(如ArrayList LinkedList Vector),有的没有下标。那么如果是有下标的集合遍历起来当然简单啦。只需要使用for循环和类似get(intdex)的方法就可以遍历,那么...

    为什么要迭代器?

    我们知道,对于集合来说,有的有下标(如ArrayList LinkedList Vector),有的没有下标。那么如果是有下标的集合遍历起来当然简单啦。只需要使用for循环和类似get(intdex)的方法就可以遍历,那么对于没有下标的集合呢?没有下标的集合怎么遍历?
    迭代器,即Collection集合元素通用的获取方式。取出元素之前判断集合中是否有元素,如果有,就取出来,知道直到取出集合中所有元素。
    简而言之,迭代器就是遍历Collection集合的。

    如何使用迭代器

    知道了迭代器的实现原理后迭代器就很简单了。总结一下,迭代器的使用共有三步。这里的代码实现就用Collection类索引指向ArrarList的多态为例子(Collection的其他子类改变指向的对象即可实现多态复用,因为Collection是这几个类的根类。)
    1.创建迭代器索引,使用多态,让索引指向对应的集合返回的迭代器(注意,迭代器的泛型必须和集合的泛型相同!)

    		Collection<Integer> myColl=new ArrayList<Integer>();
            myColl.add(3);
            myColl.add(1);
            myColl.add(6);
            myColl.add(3333);
            Iterator<Integer> it=myColl.iterator();
    

    2.使用hasNext()判断是否有下一个,使用next()访问下一个。

    while(it.hasNext()){
                System.out.println(it.next());
     }
    

    最后别忘了,iterator接口是在java.util包中。

    import java.util.Iterator;
    

    我们换个泛型,将Integer换成String再玩一遍

    import java.util.Collection;
    import java.util.LinkedList;
    import java.util.Iterator;
    public class Main{
        public static void main(String[] args){
            Collection<String> myColl=new LinkedList<String>();
            myColl.add("张三");
            myColl.add("林朝英");
            myColl.add("王重阳");
            myColl.add("黄蓉");
            myColl.add("郭靖");
            myColl.add("小龙女");
            myColl.add("尹志平");
            Iterator<String> it=myColl.iterator();
            System.out.println("我是跑龙套的"+it.next());
            while(it.hasNext()){
                System.out.println(it.next()+"深爱着"+it.next());
            }
        }
    }
    

    运行结果:
    在这里插入图片描述
    遍历完成,以后我们学了Set接口下的没有下标的子类,就要熟练使用迭代器遍历集合了。

    迭代器的实现原理

    迭代器的实现原理很好理解,就是当我们使用多态让一个迭代器接口索引指向一个集合的迭代器对象的时候,计算机底层其实有一个指针指向索引-1,是的就是索引-1.
    而**hasNext()**就是判断下一个索引的值是否存在。
    next()干两件事:1.取出下一个元素。2.指针向后移动一位。
    将这些最重要的就是我们要引出一个重要的事情:C++也好,java也好,底层容器大量使用这种迭代器遍历,导致绝大多数(基本所有)与下标相关的操作都是左闭右开

    增强for循环(foreach循环)

    有了迭代器的基本原理,自从JDK1.5以后推出了一种简化我们上述遍历集合的方法(也可以用来遍历数组)。
    这里多扩展一点,Collection集合为什么能使用增强for遍历呢,我们查看java官方文档,发现:
    在这里插入图片描述
    发现Collection集合继承了这么个东西,点开这个东西
    在这里插入图片描述
    这也就是Collection集合可以使用foreach循环(增强for循环)的原因:
    实现了 Iterable接口

    具体使用代码

    import java.util.Collection;
    import java.util.LinkedList;
    //import java.util.Iterator;
    public class Main{
        public static void main(String[] args){
            Collection<String> myColl=new LinkedList<String>();
            myColl.add("林朝英");
            myColl.add("王重阳");
            myColl.add("黄蓉");
            myColl.add("郭靖");
            myColl.add("小龙女");
            myColl.add("尹志平");
            for(String temp:myColl){
                System.out.println(temp);
            }
        }
    }
    

    在这里插入图片描述
    打印出来的结果是这样的:
    在这里插入图片描述
    不得不说,这样遍历起来确实很方便,但是操作就不那么灵活了。
    比如我想要打印出小龙女爱尹志平就不那么方便了。所以如果想要
    灵活的操作,建议还是自己创建迭代器,然后用while循环操作。
    (当然,增强for的底层还是迭代器)

    展开全文
  • 主要介绍了JavaIterator迭代器的用法,比较简单易懂,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • [转载] Java Iterator迭代器详解

    千次阅读 2016-03-06 12:32:00
    Iterator(迭代器)作为一种设计模式,迭代器可以用于遍历一个对象,对于这个对象的底层结构开发人员不必去了解。 Java中的Iterator一般称为“轻量级”对象,创建它的代价是比较小的。这里笔者不会去考究迭代器这种...

    Iterator(迭代器)作为一种设计模式,迭代器可以用于遍历一个对象,对于这个对象的底层结构开发人员不必去了解。

    Java中的Iterator一般称为“轻量级”对象,创建它的代价是比较小的。这里笔者不会去考究迭代器这种设计模式,仅在JDK代码层面上谈谈迭代器的时候以及使用迭代器的好处。

    Iterator详解

    Iterator是作为一个接口存在的,它定义了迭代器所具有的功能。这里我们就以Iterator接口来看,不考虑起子类ListIterator。其源码如下:

    package java.util;  
    public interface Iterator<E> {  
        boolean hasNext();  
        E next();  
        void remove();  
    }  

    对于这三个方法所实现的功能,字面意义就是了。不过貌似对迭代器的工作“过程”还是迷雾,接下来我们以一个实际例子来看。
    List<String> list = new ArrayList<String>();  
            list.add("TEST1");  
            list.add("TEST2");  
            list.add("TEST3");  
            list.add("TEST4");  
            list.add("TEST6");  
            list.add("TEST5");  
            Iterator<String> it = list.iterator();   
            while(it.hasNext())  
            {  
                System.out.println(it.next());  
            }  
    这段代码的输出结果不用多说,这里的it更像是“游标”,不过这游标具体做了啥,我们还得通过list.iterator()好好看看。通过源码了解到该方法产生了一个实现Iterator接口的对象。
    private class Itr implements Iterator<E> {  
            
           int cursor = 0;  
           int lastRet = -1;  
           int expectedModCount = modCount;  
           public boolean hasNext() {  
               return cursor != size();  
           }  
      
           public E next() {  
               checkForComodification();  
               try {  
                   int i = cursor;  
                   E next = get(i);  
                   lastRet = i;  
                   cursor = i + 1;  
                   return next;  
               } catch (IndexOutOfBoundsException e) {  
                   checkForComodification();  
                   throw new NoSuchElementException();  
               }  
           }  
      
           public void remove() {  
               if (lastRet < 0)  
                   throw new IllegalStateException();  
               checkForComodification();  
      
               try {  
                   AbstractList.this.remove(lastRet);  
                   if (lastRet < cursor)  
                       cursor--;  
                   lastRet = -1;  
                   expectedModCount = modCount;  
               } catch (IndexOutOfBoundsException e) {  
                   throw new ConcurrentModificationException();  
               }  
           }  
      
           final void checkForComodification() {  
               if (modCount != expectedModCount)  
                   throw new ConcurrentModificationException();  
           }  
       }  
    对于上述的代码不难看懂,有点疑惑的是int expectedModCount = modCount;这句代码其实这是集合迭代中的一种“快速失败”机制,这种机制提供迭代过程中集合的安全性。 阅读 源码就可以知道ArrayList中存在modCount对象,增删操作都会使modCount++,通过两者的对比迭代器可以快速的知道迭代过程中是否存在list.add()类似的操作,存在的话快速失败!
    以一个实际的例子来看,简单的修改下上述代码。
    while(it.hasNext())  
            {  
                System.out.println(it.next());  
                list.add("test");  
            }  
    这就会抛出一个下面的异常,迭代终止。

    对于快速失败机制以前文章中有总结,现摘录过来:
    Fail-Fast(快速失败)机制:
    仔细观察上述的各个方法,我们在源码中就会发现一个特别的属性modCount,API解释如下:
    The number of times this list has been structurally modified. Structural modifications are those that change the size of the list, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results.
    记录修改此列表的次数:包括改变列表的结构,改变列表的大小,打乱列表的顺序等使正在进行迭代产生错误的结果。
    Tips:仅仅设置元素的值并不是结构的修改
    我们知道的是ArrayList是线程不安全的,如果在使用迭代器的过程中有其他的线程修改了List就会抛出ConcurrentModificationException这就是Fail-Fast机制。  
     
    那么快速失败究竟是个什么意思呢?
    在ArrayList类创建迭代器之后,除非通过迭代器自身remove或add对列表结构进行修改,否则在其他线程中以任何形式对列表进行修改,迭代器马上会抛出异常,快速失败。
     
    迭代器的好处
    通过上述我们明白了迭代是到底是个什么,迭代器的使用也十分的简单。现在简要的总结下使用迭代器的好处吧。
    1、迭代器可以提供统一的迭代方式。
    2、迭代器也可以在对客户端透明的情况下,提供各种不同的迭代方式。
    3、迭代器提供一种快速失败机制,防止多线程下迭代的不安全操作。
    不过对于第三点尚需注意的是:就像上述事例代码一样,我们不能保证迭代过程中出现“快速失败”的都是因为同步造成的,因此为了保证迭代操作的正确性而去依赖此类异常是错误的!

    foreach循环
    通过阅读源码我们还发现一个Iterable接口。它包含了一个产生Iterator对象的iterator()方法,而且将Iterator对象呗foreach用来在序列中移动。对于任何实现Iterable接口的对象都可以使用foreach循环。
    foreach语法的冒号后面可以有两种类型:一种是数组,另一种是是实现了Iterable接口的类。对于数组不做讨论,我们看看实现了Iterable的类
    package com.iterator;  
      
    import java.util.Iterator;  
      
    public class MyIterable implements Iterable<String> {  
        protected String[] words = ("And that is how "  
               + "we know the Earth to be banana-shaped.").split(" ");  
       
        public Iterator<String> iterator() {  
           return new Iterator<String>() {  
               private int index = 0;  
       
               public boolean hasNext() {  
                  return index < words.length;  
               }  
       
               public String next() {  
                  return words[index++];  
               }  
       
               public void remove() {}  
           };  
        }  
         
        public static void main(String[] args){  
           for(String s:new MyIterable())  
               System.out.print(s+",");  
        }  
    }  
    And,that,is,how,we,know,the,Earth,to,be,banana-shaped.,











    展开全文
  • Java Iterator、ListIterator(迭代器详解及代码示例
  • 1.定义Iterator的定义为:对Collection进行迭代的迭代器Iterator取代了Java Collection Framework中的 Enumeration。Iterator与Enumeration主要有两点不一样:1.迭代器允许在调用者从集合中删除元素2.迭代器的方法...
  • Java-Iterator迭代器与foreach循环

    千次阅读 多人点赞 2022-04-20 23:08:32
    Iterator迭代器与foreach两种循环一、 Iterator迭代器接口1. 使用 Iterator 接口遍历集合元素2. Iterator接口的方法3. 迭代器的执行原理3.1 代码演示3.2 代码执行过程解析4. Iterator接口remove()方法4.1 代码演示...
  • IteratorJava 迭代器最简单的实现 常用方法 序号 方法 作用 1 boolean hasNext() 判断Iterator 中是否还有元素 2 <T> next() 返回下一个元素,并更新Iterator的状态 3 void remove
  • 主要介绍了Java Iterator接口遍历单列集合迭代器原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java 迭代器Iterator详解

    2019-07-07 11:24:41
    java 迭代器Iterator详解 迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列中的对象,而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象,因为创建它的代价小。 (一)Iterator在...
  • Iterator迭代器讲解

    2017-11-07 15:49:08
    javaIterator迭代器讲解,基础数据对象。
  • Java——迭代器iterator详解

    千次阅读 2018-12-18 15:41:07
    一、Iterator的API  关于Iterator主要有三个方法:hasNext()、next()、remove()  hasNext:没有指针下移操作,只是判断是否存在下一个元素  next:指针下移,返回该指针所指向的元素  remove:删除当前指针所...
  • 你好我是辰兮,很高兴你能来阅读,本篇给你介绍Java设计模式之迭代器模式,简单的讲解Iterator具体如何使用,分享给初学者,大家一起进步! 文章目录一、迭代器介绍二、ArrayList案例三、HashMap案例四、拓展相关 ...
  • Java中的迭代器Iterator接口详解---->解析加代码,简单易懂,快速上手
  • Java8为Iterator引入了一个forEachRemaining(Consumeraction)默认方法,这个方法所需的Consumer参数同样也是函数式接口。在程序调用Iterator的forEachRemaining(Consumeraction)遍历集合元素的时候,程序会依次将...
  • Iterator与Enumeration分别是实现迭代器和枚举器类的接口,下面就带大家来详解Java中的迭代迭代器Iterator与枚举器Enumeration,以及它们之间的区别.
  • 主要介绍了java迭代器的使用方法详解的相关资料,希望通过本文能帮助到大家,需要的朋友可以参考下
  • 【ES6】Iterator迭代器

    2022-03-02 16:34:55
    文章目录一、Iterator二、用法详解1. 基本用法2. 遍历不可迭代对象2.1 原生具备Iterator接口的数据结构:2.2 遍历不可迭代的对象:2.3 Generator 遍历不可迭代对象总结 一、Iterator 遍历Iterator)是一种接口...
  • 迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列中的对象,而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象,因为创建它的代价小 单向移动 迭代: 1.在取元素之前先要判断集合中...
  • Iterator迭代器中的remove()方法 Iterator内部定义了remove()方法 Iterator迭代器中的remove()方法不同于Collection接口中的remove()方法 Collection接口中的remove()方法是含参的(参数是 Object obj) 参数对象和...
  • Iterator对象称为迭代器,主要用于遍历Collection集合中的元素。 GOF给迭代器模式定义为:提供一种方法访问容器对象中各个元素,而不暴露该对象的内部细节,迭代器模式就是为容器而生的,类似于飞机上的空姐。 ...
  • 主要介绍了java 迭代器模式实例详解的相关资料,需要的朋友可以参考下
  • Java迭代器详解,看这一篇就够了

    千次阅读 多人点赞 2022-01-27 10:08:51
    Java迭代器详解,看这一篇就够了!
  • 本文也介绍了迭代器Iterator)的使用,使用迭代器的好处是不用关注容器的内部细节,用同样的方式遍历不同类型的容器。在下方公众号【架构师修炼】菜单中可自行获取专属架构视频资料,无套路分享,包括不限于 java...
  • 详解JavaIterator迭代器的用法迭代器(Iterator)迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列中的对象,而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象,因为创建它的代价小...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,380
精华内容 4,552
关键字:

javaiterator迭代器详解