精华内容
下载资源
问答
  • Java中Iterator类的详细介绍

    万次阅读 多人点赞 2019-07-10 20:39:59
    迭代器模式:就是提供一种方法对一个容器对象的各个元素进行访问,而又不暴露该对象容器的内部细节。 概述  Java集合框架的集合,我们有时候称之为容器。容器的种类有很多种,比如ArrayList、LinkedList、...

    迭代器模式:就是提供一种方法对一个容器对象中的各个元素进行访问,而又不暴露该对象容器的内部细节。
    概述
      Java集合框架的集合类,我们有时候称之为容器。容器的种类有很多种,比如ArrayList、LinkedList、HashSet…,每种容器都有自己的特点,ArrayList底层维护的是一个数组;LinkedList是链表结构的;HashSet依赖的是哈希表,每种容器都有自己特有的数据结构。
      因为容器的内部结构不同,很多时候可能不知道该怎样去遍历一个容器中的元素。所以为了使对容器内元素的操作更为简单,Java引入了迭代器模式!
      把访问逻辑从不同类型的集合类中抽取出来,从而避免向外部暴露集合的内部结构。
    对于数组我们使用的是下标来进行处理的:

    1 int array[] = new int[3];    
    2 for (int i = 0; i < array.length; i++) {
    3     System.out.println(array[i]);
    4 }
    对ArrayList的处理
    1 List<String> list = new ArrayList<String>();
    2        for(int i = 0 ; i < list.size() ;  i++){
    3           String string = list.get(i);
    4 }
    

    对于这两种方式,我们总是都知道它的内部结构,访问代码和集合本身是紧密耦合的,无法将访问逻辑从集合类和客户端代码中分离出来。不同的集合会对应不同的遍历方法,客户端代码无法复用。在实际应用中如何将上面两个集合整合是相当麻烦的。所以才有Iterator,它总是用同一种逻辑来遍历集合。使得客户端自身不需要来维护集合的内部结构,所有的内部状态都由Iterator来维护。客户端不用直接和集合进行打交道,而是控制Iterator向它发送向前向后的指令,就可以遍历集合。
    1.java.util.Iterator
    下面让我们看看Java中的Iterator接口是如何实现的
      在Java中Iterator为一个接口,它只提供了迭代的基本规则。在JDK中它是这样定义的:对Collection进行迭代的迭代器。迭代器取代了Java Collection Framework中的Enumeration。迭代器与枚举有两点不同:
      1. 迭代器在迭代期间可以从集合中移除元素。
      2. 方法名得到了改进,Enumeration的方法名称都比较长。
    其接口定义如下:

    package java.util;
    public interface Iterator<E> {
        boolean hasNext();//判断是否存在下一个对象元素
    
        E next();//获取下一个元素
    
        void remove();//移除元素
    }
    

    2.Iterable
      Java中还提供了一个Iterable接口,Iterable接口实现后的功能是‘返回’一个迭代器,我们常用的实现了该接口的子接口有:Collection、List、Set等。该接口的iterator()方法返回一个标准的Iterator实现。实现Iterable接口允许对象成为Foreach语句的目标。就可以通过foreach语句来遍历你的底层序列。
      Iterable接口包含一个能产生Iterator对象的方法,并且Iterable被foreach用来在序列中移动。因此如果创建了实现Iterable接口的类,都可以将它用于foreach中。
    Iterable接口的具体实现:
    Package java.lang;

    import java.util.Iterator;
    public interface Iterable {
    Iterator iterator();
    }
    使用迭代器遍历集合:

     1 public static void main(String[] args) {
     2         List<String> list = new ArrayList<String>();
     3         list.add("张三1");
     4         list.add("张三2");
     5         list.add("张三3");
     6         list.add("张三4");
     7         
     8         List<String> linkList = new LinkedList<String>();
     9         linkList.add("link1");
    10         linkList.add("link2");
    11         linkList.add("link3");
    12         linkList.add("link4");
    13         
    14         Set<String> set = new HashSet<String>();
    15         set.add("set1");
    16         set.add("set2");
    17         set.add("set3");
    18         set.add("set4");
    19         //使用迭代器遍历ArrayList集合
    20         Iterator<String> listIt = list.iterator();
    21         while(listIt.hasNext()){
    22             System.out.println(listIt.next());
    23         }
    24         //使用迭代器遍历Set集合
    25         Iterator<String> setIt = set.iterator();
    26         while(setIt.hasNext()){
    27             System.out.println(listIt.next());
    28         }
    29         //使用迭代器遍历LinkedList集合
    30         Iterator<String> linkIt = linkList.iterator();
    31         while(linkIt.hasNext()){
    32             System.out.println(listIt.next());
    33         }
    34 }
    

    使用foreach遍历集合:

    List<String> list = new ArrayList<String>();
    list.add("张三1");
    list.add("张三2");
    list.add("张三3");
    list.add("张三4");
    for (String string : list) {
        System.out.println(string);
    }
    

    可以看出使用foreach遍历集合的优势在于代码更加的简洁,更不容易出错,不用关心下标的起始值和终止值。
    3.Iterator遍历时不可以删除集合中的元素问题
      在使用Iterator的时候禁止对所遍历的容器进行改变其大小结构的操作。例如: 在使用Iterator进行迭代时,如果对集合进行了add、remove操作就会出现ConcurrentModificationException异常。

     1         List<String> list = new ArrayList<String>();
     2         list.add("张三1");
     3         list.add("张三2");
     4         list.add("张三3");
     5         list.add("张三4");
     6         
     7         //使用迭代器遍历ArrayList集合
     8         Iterator<String> listIt = list.iterator();
     9         while(listIt.hasNext()){
    10             Object obj = listIt.next();
    11             if(obj.equals("张三3")){
    12                 list.remove(obj);
    13             }
    14         }
    

    因为在你迭代之前,迭代器已经被通过list.itertor()创建出来了,如果在迭代的过程中,又对list进行了改变其容器大小的操作,那么Java就会给出异常。因为此时Iterator对象已经无法主动同步list做出的改变,Java会认为你做出这样的操作是线程不安全的,就会给出善意的提醒(抛出ConcurrentModificationException异常)
    Iterator的实现源码:

     1     private class Itr implements Iterator<E> {
     2         int cursor;       // index of next element to return
     3         int lastRet = -1; // index of last element returned; -1 if no such
     4         int expectedModCount = modCount;
     5 
     6         public boolean hasNext() {
     7             return cursor != size;
     8         }
     9 
    10         @SuppressWarnings("unchecked")
    11         public E next() {
    12             checkForComodification();
    13             int i = cursor;
    14             if (i >= size)
    15                 throw new NoSuchElementException();
    16             Object[] elementData = ArrayList.this.elementData;
    17             if (i >= elementData.length)
    18                 throw new ConcurrentModificationException();
    19             cursor = i + 1;
    20             return (E) elementData[lastRet = i];
    21         }
    22 
    23         public void remove() {
    24             if (lastRet < 0)
    25                 throw new IllegalStateException();
    26             checkForComodification();
    27 
    28             try {
    29                 ArrayList.this.remove(lastRet);
    30                 cursor = lastRet;
    31                 lastRet = -1;
    32                 expectedModCount = modCount;
    33             } catch (IndexOutOfBoundsException ex) {
    34                 throw new ConcurrentModificationException();
    35             }
    36         }
    37 
    38         final void checkForComodification() {
    39             if (modCount != expectedModCount)
    40                 throw new ConcurrentModificationException();
    41         }
    42     }
    

    通过查看源码发现原来检查并抛出异常的是checkForComodification()方法。在ArrayList中modCount是当前集合的版本号,每次修改(增、删)集合都会加1;expectedModCount是当前迭代器的版本号,在迭代器实例化时初始化为modCount。我们看到在checkForComodification()方法中就是在验证modCount的值和expectedModCount的值是否相等,所以当你在调用了ArrayList.add()或者ArrayList.remove()时,只更新了modCount的状态,而迭代器中的expectedModCount未同步,因此才会导致再次调用Iterator.next()方法时抛出异常。但是为什么使用Iterator.remove()就没有问题呢?通过源码的第32行发现,在Iterator的remove()中同步了expectedModCount的值,所以当你下次再调用next()的时候,检查不会抛出异常。
      使用该机制的主要目的是为了实现ArrayList中的快速失败机制(fail-fast),在Java集合中较大一部分集合是存在快速失败机制的。
      快速失败机制产生的条件:当多个线程对Collection进行操作时,若其中某一个线程通过Iterator遍历集合时,该集合的内容被其他线程所改变,则会抛出ConcurrentModificationException异常。
      所以要保证在使用Iterator遍历集合的时候不出错误,就应该保证在遍历集合的过程中不会对集合产生结构上的修改。
    使用Foreach时对集合的结构进行修改会出现异常:
      上面我们说了实现了Iterable接口的类就可以通过Foreach遍历,那是因为foreach要依赖于Iterable接口返回的Iterator对象,所以从本质上来讲,Foreach其实就是在使用迭代器,在使用foreach遍历时对集合的结构进行修改,和在使用Iterator遍历时对集合结构进行修改本质上是一样的。所以同样的也会抛出异常,执行快速失败机制。
      foreach是JDK1.5新增加的一个循环结构,foreach的出现是为了简化我们遍历集合的行为。
    for循环与迭代器的对比:
      * 效率上各有各的优势:
        > ArrayList对随机访问比较快,而for循环中使用的get()方法,采用的即是随机访问的方法,因此在ArrayList里for循环快。
        > LinkedList则是顺序访问比较快,Iterator中的next()方法采用的是顺序访问方法,因此在LinkedList里使用Iterator较快。
        > 主要还是要依据集合的数据结构不同的判断。

    展开全文
  • 下面小编就为大家带来一篇浅谈java Iterator.remove()方法的用法(详解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java中Iterator类的用法

    2019-10-28 20:06:28
    2、两种常用的方法: (1)boolean hasNext():如果仍有元素可以迭代,则返回true,判断集合还有没有下一个元素,有 就返回true,没有就返回false。 (2)E next():返回迭代的下一个元素,取出集合的下一个元素...

    java.util.Iterator

    1、迭代器,对接口进行遍历。
    2、两种常用的方法:
    (1)boolean hasNext():如果仍有元素可以迭代,则返回true,判断集合中还有没有下一个元素,有 就返回true,没有就返回false。
    (2)E next():返回迭代的下一个元素,取出集合中的下一个元素。
    3、Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊。
    4、Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象。
    Iterator iterator():返回在此collection的元素上进行迭代的迭代器。
    5、迭代器的使用步骤:
    (1)使用集合的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收。
    (2)使用Iterator接口中的方法hasNext()判断还有没有下一个元素。
    (3)使用Iterator接口中的方法next()取出集合中的下一个元素。
    6、增强for循环:底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写。
    Collection extends Iterator:所有的单列集合都可以使用增强for。
    public interface Iterator实现这个接口允许对象成为“foreach“语句的目标。
    增强for循环:用来遍历集合和数组。
    格式:
    for (集合/数组的数据类型 变量名:集合名/数组名) {
    sout(变量名);
    }

    展开全文
  • 迭代器类Iterator的next方法

    千次阅读 2020-04-01 23:25:04
    next()是java迭代器Iterator)的方法,获得当前游标指向的下一个元素,详细说明和应用如下: 1、迭代器(Iterator)介绍  迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列的对象,而开发人员不...

    迭代器类(Iterator)

    next()是java迭代器类(Iterator)的方法,获得当前游标指向的下一个元素,详细说明和应用如下:
    1、迭代器(Iterator)介绍  
    迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列中的对象,而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象,因为创建它的代价小。  Java中的Iterator功能比较简单,并且只能单向移动: 
     (1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时,它返回序列的第一个元素。注意:iterator()方法是java.lang.Iterable接口,被Collection继承。 
     (2) 使用next()获得序列中的下一个元素。  
     (3) 使用hasNext()检查序列中是否还有元素。  
     (4) 使用remove()将迭代器新返回的元素删除。  
     Iterator是Java迭代器最简单的实现,为List设计的ListIterator具有更多的功能,它可以从两个方向遍历List,也可以从List中插入和删除元素
    
    展开全文
  • 主要介绍了Java集合Iterator迭代接口的实现方法,非常不错,具有参考借鉴家,对Java 结合iterator知识感兴趣的朋友一起看看吧
  • Iterator 属于迭代输出,基本的操作原理:是不断的判断是否有下一个元素,有的话,则直接输出。 二、使用步骤 1.常用方法 E next() 会返回迭代器的下一个元素,并且更新迭代器的状态。 boolean h


    一、Iterator是什么?

    Iterator不是一个集合,它是一种用于访问集合的方法,可用于迭代 ArrayList 和 HashSet 等集合。

    Iterator 属于迭代输出,基本的操作原理:是不断的判断是否有下一个元素,有的话,则直接输出。

    二、使用步骤

    1.常用方法

    E next()     会返回迭代器的下一个元素,并且更新迭代器的状态。
    boolean hasNext()  用于检测集合中是否还有元素。存在则返回truedefault void remove()     将迭代器返回的元素删除。
    

    2.next()使用

    next() 会返回迭代器的下一个元素,并且更新迭代器的状态。

    import java.util.Iterator; // 引入 Iterator 类
    import java.util.ArrayList;
    
    public class Demo {
        public static void main(String[] args) {
            // 创建集合
            ArrayList<String> data = new ArrayList<>();
            // 为集合添加元素
            data.add("Google");
            data.add("IDEA");
            data.add("Baidu");
            // 获取迭代器
            Iterator<String> iterator = data.iterator();
            // 输出集合中第一个元素
            System.out.println(iterator.next());
            // 输出集合中第二个元素
            System.out.println(iterator.next());
        }
    }
    

    执行以上代码,结果输出为:

    Google
    IDEA
    

    3.循环集合元素hasNext()

    hasNext() 用于检测集合中是否还有元素。存在则返回true。

    让迭代器逐个返回集合中所有元素最简单的方法是使用 while 循环:

    
    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class Demo {
        public static void main(String[] args) {
            // 创建集合
            ArrayList<String> data = new ArrayList<>();
            data.add("Google");
            data.add("IDEA");
            data.add("Baidu");
            // 获取迭代器
            Iterator<String> iterator = data.iterator();
            // hasNext 检查集合中是否还有元素,如果有则进入循环。
            while (iterator.hasNext()){
            	// 循环打印集合中的 元素
                System.out.println(iterator.next());
            }
        }
    }
    

    执行以上代码,输出结果如下:

    Google
    IDEA
    Baidu
    

    4. remove()

    remove() 将迭代器返回的元素删除。

    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class Demo {
        public static void main(String[] args) {
            // 创建集合
            ArrayList<String> data = new ArrayList<>();
            data.add("Google");
            data.add("IDEA");
            data.add("Baidu");
            // 获取迭代器
            Iterator<String> iterator = data.iterator();
            iterator.next();
            // 使用remove时,迭代器的指针不能为初始位置,否则会报错
            iterator.remove();
            // 输出集合中第一个元素
            System.out.println(iterator.next());
            // 输出集合中第二个元素
            System.out.println(iterator.next());
    
        }
    }
    
    

    执行以上代码,输出结果如下:

    IDEA
    Baidu
    

    可以看到,原本集合中的第一个元素Google被干掉了。

    展开全文
  • 一. Collection(集合)接口Collection是JAVA语言实现一些普通数据结构的接口。... 返回一个Iterator接口的对象,用于访问集合每个元素。2. boolean add(); 添加一个对象到集合,若集合发生改变,...
  • public interface Iterator<T> { /** * Task:测定迭代器是否完成遍历并越过数据集的最后一个元素 * @return 迭代器若有下一个元素返回 true */ public boolean hasNext(); /** * Task:提取集合当前...
  • 前言:虽然集合没有索引,但是为了方便说明迭代器的方法,就先引用索引这个名词,实际上集合...Iterator boolean hasNext(); E next(); default void remove() { throw new UnsupportedOperationException("rem
  • java集合Collection介绍和iterator方法

    千次阅读 2018-11-15 20:48:40
    集合的继承关系和基本方法 数组和集合 数组的长度是固定,改变数组长度的方式是创建新的数组,将旧数组复制到新的数组里. 集合能存储任意长度的对象,集合的长度可以随着元素的增加而增加,随元素减少而减少 ...
  • JAVAIterator

    2019-03-20 20:12:32
    Iterator 接口主要用于遍历Collection集合的元素,Iterator对象也被称为迭代器。...Iterator接口定义了4个方法。 boolean hasNext(): 判断是否有下一个可访问的元素,如果有返回true,否则返回false。 Object ...
  • 如果对正在被迭代的集合进行结构上的改变(即对该集合使用add、remove或clear方法),那么迭代器就不再合法(并且在其后使用该迭代器将会有ConcurrentModificationException异常被抛出). 如果使用迭代器自己的...
  • 1、迭代器Iterator在集合的作用 迭代器是集合的专用遍历方式,它是依赖于集合而存在的,由集合对象调用 iterator() 方 法而创建,常用于获取集合的对象元素。 集合的获取功能的使用通常都为以下步骤: ...
  • collection接口的iterator方法返回类型是接口类型,怎么理解?
  • Collection和Iterator接口方法详解

    千次阅读 2017-07-20 19:14:05
    Collection接口里常用方法: 下面实例示范了如何通过上面的方法来操作Collection集合里的元素。package base1;import java.util.ArrayList; import java.util.Collection; import java.util.HashSet;public class...
  • 提示:迭代器 Iterator()遍历类中的元素,其中方法主要用 hasnext()判断是否有下一个元素, next()元素获得元素 package lanqiaobei; import java.util.*; public class ss { public static void main(String ...
  • java中Iterator用法总结

    万次阅读 2018-08-04 23:12:05
    Java中Iterator用法 迭代器(Iterator)  迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列的对象,而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象,因为创建它的代价小。 ...
  • c++ iterator(迭代器)分类及其使用

    千次阅读 2018-10-03 20:54:30
    总所周知,c++的stl提出了iterator的概念,这是C所没有的.在一般的使用,iterator的行为很像c内建的指针.而在java和c#索性就直接取消了指针,而采用类似iterator的做法来代替了指针.很多编程人员在使用iterator的...
  • Java Iterator(迭代器)不是一个集合,它是一种用于访问集合的方法,可用于迭代 ArrayList 和 HashSet 等集合。 Iterator 是 Java 迭代器最简单的实现,ListIterator 是 Collection API 的接口, 它扩展了 ...
  • 每个实现Iterable接口的必须提供一个iterator方法,返回一个Iterator对象,ArrayList也不例外 public Iterator<E> iterator() { return new Itr(); } 返回的是一个Itr的对象,接下来我们来看它的部分...
  • Collection接口的remove()方法本质上就是各个底层自己实现的remove()方法,其优点就是当其不是遍历的情况下,效率应该是最快的。但是其在遍历的情况下,将会导致各种问题,比如在现在 Collection c = new ArrayList...
  • C++自定义模板类中STL iterator未定义的问题最近在写一个模板用到了stl map迭代器,遇见一下问题#include #include using namespace std; template class A { public: void iterate() { map, T>::iterator ...
  • C++/C++11头文件iterator的使用

    万次阅读 2017-09-14 21:00:20
    是C++标准程序库的一个头文件,定义了C++ STL标准的一些迭代器模板,这些都是以std::iterator为基类派生出来的。迭代器提供对集合(容器)元素的操作能力。迭代器提供的基本操作就是访问和遍历。迭代器模拟了...
  • s:iterator 的status 使用方法

    千次阅读 2015-08-04 10:17:46
    s:iterator 的status 使用方法 1:#status.odd 是否奇数行 2:#status.count 当前行数 3:#status.index 当前行的序号,从0开始『#status.count=#status.index+1』 4:#status.first 是否第一行 5:#status....
  • Scala iterator迭代器

    千次阅读 2020-01-17 17:15:59
    scala针对每一集合都提供了一个迭代器(iterator)用来迭代访问集合 使用迭代器遍历集合 使用iterator方法可以从集合获取一个迭代器 迭代器的两个基本操作 hasNext——查询容器是否有下一个元素 next——返回...
  • 经常需要遍历集合的所有元素,数组我们可能会使用for循环通过其索引来遍历整个集合,但是有些集合没有索引,我们无法通过for循环来遍历,针对这种需求,JDK专门提供了一个接口java.util.IteratorIterator...
  • 一、For 循环、 二、For 循环遍历 Iterator 对象、 三、Iterator 遍历要求、 四、IntArray 源码解析
  • Iterator接口

    千次阅读 2019-02-24 15:15:32
    1:所有实现了Collection接口的容器都有一个iterator方法用以返回一个实现了Iterator接口的对象。 2:Iterator对象称作迭代器,用以方便的实现对容器内元素的遍历操作。 3:Iterator接口定义了如下方法 可以将...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 279,722
精华内容 111,888
关键字:

属于iterator类中的方法