精华内容
下载资源
问答
  • //迭代器可以修改 for(vector<Person>::iterator it=g.begin(); it != g.end(); it++) { (*it).m_score = 100; } }</code></pre> 我看stl源码也只是做了个*操作 <p>// for_each ...
  • Java迭代器(iterator详解以及for循环区别)

    万次阅读 多人点赞 2018-05-31 19:07:18
    前言: 迭代器是一种模式、详细可见其设计模式,可以使得序列类型的数据结构的遍历行为与被遍历的对象分离...实现了这个可以配合foreach使用~Iterator:迭代器,提供迭代机制的对象,具体如何迭代是这个Iterator接口...

    前言:   

         迭代器是一种模式、详细可见其设计模式,可以使得序列类型的数据结构的遍历行为与被遍历的对象分离,即我们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就可以遍历这个对象的内部。

    Iterable:实现这个接口的集合对象支持迭代,是可以迭代的。实现了这个可以配合foreach使用~

    Iterator:迭代器,提供迭代机制的对象,具体如何迭代是这个Iterator接口规范的。

    //Iterable JDK源码
    //可以通过成员内部类,方法内部类,甚至匿名内部类去实现Iterator
    
    public interface Iterable<T>
    {
      
        Iterator<T> iterator();
    }

    Iterable还有一个默认的方法forEach()、

    而Iterator接口:

    包含三个方法:hasNext,next,remove、remove一般很少用到、

    public interface Iterator<E> {
       
    
        boolean hasNext();    //每次next之前,先调用此方法探测是否迭代到终点
    
        E next();            //返回当前迭代元素 ,同时,迭代游标后移
                  
    
         /*删除最近一次已近迭代出出去的那个元素。
         只有当next执行完后,才能调用remove函数。
         比如你要删除第一个元素,不能直接调用 remove()   而要先next一下( );
         在没有先调用next 就调用remove方法是会抛出异常的。
         这个和MySQL中的ResultSet很类似
        */
        void remove() 
        {
            throw new UnsupportedOperationException("remove");
        }
    }

    注意一点:

            迭代出来的元素都是原来集合元素的拷贝。

            Java集合中保存的元素实质是对象的引用,而非对象本身。

            迭代出的对象也是引用的拷贝,结果还是引用。那么如果集合中保存的元素是可变类型的,那么可以通过迭代出的元素修改原集合中的对象。

    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class test {
        public static void main(String[] args) {
            ArrayList<Person> array = new ArrayList<Person>();
    
            Person p1 = new Person("Tom1");
            Person p2 = new Person("Tom2");
            Person p3 = new Person("Tom3");
            Person p4 = new Person("Tom4");
    
            array.add(p1);
            array.add(p2);
            array.add(p3);
            array.add(p4);
    
            Iterator<Person> iterator = array.iterator();
    
            for (Person pp : array){
                System.out.println(pp.getName());
            }
    
            System.out.println("\r\n" + "-----利用Lambda表达式的foreach-----" + "\r\n");
            array.forEach(obj -> System.out.println(obj.getName()));
    
    
            System.out.println("\r\n" + "-----利用for循环-----" + "\r\n");
            for(Person p : array){
                p.setName("wang");
            }
    
            while(iterator.hasNext()){
                System.out.println(iterator.next().getName()); //输出的是wang,而不是tom
            }
    
    
    
        }
    }

    Map遍历也是一样的~

    public static void main(String[] args) {
            Map map = new HashMap();
            for(int i = 0; i < 10; i ++){
                map.put(i, String.valueOf("map" + i));
            }
            Iterator iterMap = map.entrySet().iterator();
            while(iterMap.hasNext()){
                Map.Entry strMap = (Map.Entry)iterMap.next();
                System.out.println("key为:" + strMap.getKey() +
                        ", value为:" + strMap.getValue());
            }
        }

    那么当Iterator迭代访问Collection集合中元素时,Collection的元素不能改变(多个线程的修改),只有通过Iterator的remove()方法删除上一次next()方法返回集合才可以。这样会引发ModificationException异常,即fail-fast机制

      //创建集合,添加元素和上述一样      
            Iterator<Person> iterator = array.iterator();
    
            while(iterator.hasNext()){
               String name = iterator.next().getName();
               System.out.println(name);
               if(name.equals("Tom3")){
                   //array.remove(name);  不推荐这种方式
                   iterator.remove();
               }
            }

    Iterator与泛型搭配:

            Iterator对集合类中的任何一个实现类,都可以返回这样一个Iterator对象。可以适用于任何一个类。

            因为集合类(List和Set等)可以装入的对象的类型是不确定的,从集合中取出时都是Object类型,用时都需要进行强制转化,这样会很麻烦,用上泛型,就是提前告诉集合确定要装入集合的类型,这样就可以直接使用而不用显示类型转换.非常方便.

    foreach和Iterator的关系:

            for each以用来处理集合中的每个元素而不用考虑集合定下标。就是为了让用Iterator简单。但是删除的时候,区别就是在remove,循环中调用集合remove会导致原集合变化导致错误,而应该用迭代器的remove方法。


    使用for循环还是迭代器Iterator对比:

            采用ArrayList对随机访问比较快,而for循环中的get()方法,采用的即是随机访问的方法,因此在ArrayList里,for循环较快

            采用LinkedList则是顺序访问比较快,iterator中的next()方法,采用的即是顺序访问的方法,因此在LinkedList里,使用iterator较快

    从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.

            而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素,而不用考虑集合类的内部实现(只要它实现了 java.lang.Iterable 接口),如果使用 Iterator 来遍历集合中元素,一旦不再使用 List 转而使用 Set 来组织数据,那遍历元素的代码不用做任何修改,如果使用 for 来遍历,那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.(还是说明了一点遍历和集合本身分离了


    展开全文
  • 可以看出,使用for each循环语句的优势在于更加简洁,更不容易出错,不必关心下标的起始值终止值。 forEach不是关键字,关键字还是for,语句是由iterator实现的,他们最大的不同之处就在于remove()方法上。 一般...

    可以看出,使用for each循环语句的优势在于更加简洁,更不容易出错,不必关心下标的起始值和终止值。

    forEach不是关键字,关键字还是for,语句是由iterator实现的,他们最大的不同之处就在于remove()方法上。

     

    一般调用删除和添加方法都是具体集合的方法,例如:

    List list = new ArrayList(); list.add(...); list.remove(...);

    但是,如果在循环的过程中调用集合的remove()方法,就会导致循环出错,因为循环过程中list.size()的大小变化了,就导致了错误。 所以,如果想在循环语句中删除集合中的某个元素,就要用迭代器iterator的remove()方法,因为它的remove()方法不仅会删除元素,还会维护一个标志,用来记录目前是不是可删除状态,例如,你不能连续两次调用它的remove()方法,调用之前至少有一次next()方法的调用。

    forEach就是为了让用iterator循环访问的形式简单,写起来更方便。当然功能不太全,所以但如有删除操作,还是要用它原来的形式。

     

    4 使用for循环与使用迭代器iterator的对比

     

    效率上的各有有事

    采用ArrayList对随机访问比较快,而for循环中的get()方法,采用的即是随机访问的方法,因此在ArrayList里,for循环较快

    采用LinkedList则是顺序访问比较快,iterator中的next()方法,采用的即是顺序访问的方法,因此在LinkedList里,使用iterator较快

    从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.

    而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素,而不用考虑集合类的内部实现(只要它实现了 java.lang.Iterable 接口),如果使用 Iterator 来遍历集合中元素,一旦不再使用 List 转而使用 Set 来组织数据,那遍历元素的代码不用做任何修改,如果使用 for 来遍历,那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.

     

    final Result<List<CandidatePair>> result = fieldDefineService.getCandidatePairs(FIELD_CODE);
            final List<CandidatePair> pairs = result.getData();
            for (Iterator<CandidatePair> it = pairs.iterator(); it.hasNext(); ) {
                final CandidatePair pair = it.next();
                final String pairValue = pair.getValue();
                switch (resourceType) {
                    case CUSTOM:
                    case ACCESS:
                        if (!resourceType.getCandidiateValue().equals(pairValue)) {
                            it.remove();
                        }
                        break;
                    case DASS:
                        if (ResourceType.CUSTOM.getCandidiateValue().equals(pairValue)) {
                            it.remove();
                        }
                        break;
                    case DASS_EXCEPT_ACCESS:
                        if (ResourceType.CUSTOM.getCandidiateValue().equals(pairValue)
                                || ResourceType.ACCESS.getCandidiateValue().equals(pairValue)) {
                            it.remove();
                        }
                        break;
                    default:
                }
            }

     

    展开全文
  • 迭代器 迭代器(lterator)是一种接口,为各种不同的数据结构,提供统一的访问机制。 任何数据结构只要部署迭代器(lterator),就可以完成遍历操作 ...for…in、for…of、forEach区别和共同点 for…of 一般用来

    迭代器

    迭代器(lterator)是一种接口,为各种不同的数据结构,提供统一的访问机制。
    任何数据结构只要部署迭代器(lterator),就可以完成遍历操作

    1). ES6创造了一种新的遍历命令for…of循环,lterator 接口主要供for…of消费
    2). 原生具备lterator 接口的数据(可用for…of遍历)

    Array
    Arguments
    Set
    Map
    String
    TypedArray
    NodeList

    for…in、for…of、forEach的区别和共同点

    for…of 一般用来遍历 “ 数组(或类数组)” (不可以遍历对象,会报错)

    for…of 会对数组中的每一项进行遍历,并返回数组每一项的值

    const arr = ["rookie", "theshy", "ning", "puff", "boolean"]
    for (const value of arr) {
        console.log(value)
    }
    // rookie  theshy  ning  puff  boolean
    

    for…in 一般用来遍历 “ 对象 ”(也可以遍历数组,但只返回index值)

    遍历对象

    const objIG = {
        number: "5",
        mid: "rookie",
        top: "theshy",
        jg: "ning",
        adc: "puff",
        sup: "boolean"
    }
    for (const key in objIG) {
        // 输出key值,  键名 number mid top jg adc sup
        console.log(key) 
        // 输出value值,键值 5 rookie theshy ning puff boolean
        console.log(objIG[key])
    }
    

    遍历数组

    const arr = ["rookie", "theshy", "ning", "puff", "boolean"]
    for (const key in arr) { 
    	// 返回 index 0 1 2 3 4 
        console.log(key)
        // 返回 值  rookie, theshy, ning, puff, boolean
        console.log(arr[key])
    }
    

    forEach 、map

    相同点:
    1 .都是循环遍历数组中的每一项
    2 .forEach和map方法里每次执行匿名函数都支持3个参数,参数分别是item(当前每一项),index(索引值),arr(原数组)
    3 .匿名函数中的this都是指向window
    4 .只能遍历数组
    5 .都不会改变原数组

    区别:
    map方法
    1 .map方法返回一个新的数组,数组中的元素为原始数组调用函数处理后的值。
    2 .map方法不会对空数组进行检测,map方法不会改变原始数组。

    const arr = ["rookie", "theshy", "ning", "puff", "boolean"]
    const newArr = arr.map(function (currentValue, index, arr) {
        return index + 1 + ":" + currentValue
    });
    // (5) ["1:rookie", "2:theshy", "3:ning", "4:puff", "5:boolean"]
    
    展开全文
  • 迭代是函数内某段代码实现循环,而迭代与普通循环区别是:循环代码中参与运算的变量同时是保存结果的变量,当前保存的结果作为下一次循环计算的初始值。 数组 我们知道数组的定义是a = new Array(),然后对于...

    递归是重复调用函数自身实现循环。
    迭代是函数内某段代码实现循环,而迭代与普通循环的区别是:循环代码中参与运算的变量同时是保存结果的变量,当前保存的结果作为下一次循环计算的初始值。




    数组

    我们知道数组的定义是a = new Array(),然后对于给予赋值a = [1, 2, 3]
    得出a是Array所new 的一个对象,他的每个元素被视为一个属性值,从0开始对其索引。




    for-in 方法

    prop in object -MDN
    采用for-in对数组对象a进行遍历

    var a = [1, 2, 3];
    
    for(let i in a){
        console.log(a[i]);
        // 打印出 1 2 3  
        
        console.log(i);
        // 打印出 0 1 2
    } 

    当我们给予对象a新的属性时候又会是怎样的效果?

    var a = [1, 2, 3];
    a.name = "kaso";
    
    for(let i in a){
        console.log(a[i]);
        // 打印出 1 2 3 kaso 
        
        console.log(i);
        // 打印出 0 1 2 name
    } 

    可以看到for-in语句将对象a中所有的属性都遍历的一遍,但是如果我们想要的只是将数组中进行遍历又要怎么写呢?




    for-of 方法

    仅打印出集合内的元素。

    var a = ['A', 'B', 'C'];
    a.name = 'Hello';
    
    for (var x of a) {
        console.log(x); // 'A', 'B', 'C'
    }




    forEach 方法

    a=new Map;
    a=[5,1,2,["name","kaso"],["age",20]];
    
    a.forEach(function (element, index, array) {
        // element: 指向当前元素的值
        // index: 指向当前索引
        // array: 指向Array对象本身
        console.log(`${element}, index = ${index}`);
        console.log(`array`)
    });
    
    /*
    * 输出结果
    * 5, index = 0
    * 1, index = 1
    * 2, index = 2
    * name,kaso, index = 3
    * age,20, index = 4
    * 5 1 2 name kaso age 20
    */

    key等同于array,输出值列

    转载于:https://www.cnblogs.com/jilaokang/p/8641542.html

    展开全文
  • 首先是IEnumerable与IEnumerator的定义: ...2.IEnumerator接口是一个真正的集合访问,它包含MoveNext()方法Current属性,在foreach循环中,如果MoveNext()返回True,则就是用IEnumerator接口的Curre...
  • 第二堂课(集合框架) ** ...3.List的取值方式(三种):遍历(foreach) 迭代(iterator) 循环(for) 4.List集合中不可以存放值类型 ,只能使用引用类型(封装) 5.使用for移除时 中间不会留下空位置 往...
  • 2)增强for循环内部其实是使用了Iterator迭代器遍历的,只能遍历数组实现了Interable接口的集合。 3)普通for循环可以获取元素索引,增强for循环无法获取元素索引 4)增强for循环比普通for循环代码更简洁。 5)...
  • Set存放的元素无序,且不可以存放相同的元素,只能通过迭代器foreach循环遍历来取值。 Map存放的是键值对元素,它的键是不可以重复的,一旦键值重复,其值将会被覆盖,它只能通过键的值来取值。 ...
  • (1)List取出元素for循环,foreach循环,Iterator迭代器迭代 (2)Set取出元素foreach循环,Iterator迭代器迭代 (3)Map取出元素需转换为Set,然后进行Iterator迭代器迭代,或转换为Entry对象进行Iterator迭代器迭代 2、...
  • foreach的真面目

    2018-06-18 18:30:00
    在遍历数组的时候,我们一般使用一般的for循环、增强的for循环,在遍历集合的时候,我们一般使用一般的for循环、增强的for循环迭代器,当然除了这些我们还可以使用我们的工具类,Arrayscollections来遍历;...
  • 平时经常会有一些对集合的增删场景,那么普通for循环foreach迭代器它们会有一些什么区别呢?fail-fast机制又是怎么体现的呢?这篇文章从源码应用的角度进行了全面的分析。
  • List,Set,Map存取元素各有什么特点?...取出(1)List取出元素for循环,foreach循环,Iterator迭代器迭代(2)Set取出元素foreach循环,Iterator迭代器迭代(3)Map取出元素需转换为Set,然后进行Iterato...
  • IEnumberable接口成为迭代器,就一个GetEnumberator()方法;它返回的是一IEnumberator对象这是一个可以循环访问集合的对象,IEnumberator是一个集合访问器。支持foreach语句,IEnumberator定义了Current属性,...
  • 增强for循环

    2017-03-22 10:13:11
    增强for循环foreach语句,foreach简化了迭代器。 格式:// 增强for循环括号里写两个参数,第一个是声明一个变量,第二个就是需要迭代的容器 for( 元素类型 变量名 : Collection集合 & 数组 ) { …? } 高级for...
  • List集合框架

    2019-07-04 20:36:00
    ** 集合框架 ...集合的remove方法和迭代器的remove方法有什么区别? 在迭代器或者foreach循环删除的时候容易出现什么问题。 在迭代器中执行collection.remove方法 java.util.ConcurrentMod...
  • 迭代器除了遍历,还可以进行remove集合中元素的动作。 如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。 传统for高级for有什么区别呢? 高级for有一个局限性。必须有被
  • Arraylist 与 LinkedList 区别 结构上的区别 ArrayList底层实现基于动态数组,LinkedList底层实现基于双向链表。 性能上区别 ArrayList查询快,增删慢...常用的遍历列表有三种方法,分别为foreach迭代器、for循环 ...
  • 数组的循环方法扩展

    2019-05-23 17:03:42
    数组的辅助迭代器,包括 forEach(…)、 every(…) some(…)。 forEach(…) 会遍历数组中的所有值并忽略回调函数的返回值.每种辅 助迭代器都可以接受一个回调函数并把它应用到数组的每个元素上,唯一的区别就是...
  • 增强for循环foreach语句,foreach简化了迭代器。 格式:// 增强for循环括号里写两个参数,第一个是声明一个变量,第二个就是需要迭代的容器 for( 元素类型 变量名 :Collection集合 & 数组 ) {   … ...
  • 增强for循环foreach语句,foreach简化了迭代器。 格式:// 增强for循环括号里写两个参数,第一个是声明一个变量,第二个就是需要迭代的容器 for( 元素类型 变量名 : Collection集合 & 数组 ) {  … } 高级...
  • foreach语句,foreach简化了迭代器。 格式:// 增强for循环括号里写两个参数,第一个是声明一个变量,第二个就是需要迭代的容器 for( 元素类型 变量名 : Collection集合 & 数组 ) { ? } 高级for循环和传统for...
  • 公开枚举,该枚举支持在指定类型的集合上进行简单迭代。也就是说:实现了此接口的object,就可以直接使用foreach遍历此object; IEnumerable 包含一个方法,GetEnumerator,返回 IEnumerator。 IEnumerator 可以...

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

迭代器和foreach循环区别