Java基础 -- 持有对象(容器)已经详细介绍到,集合(Collection)的种类有很多种,比如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向它发送向前向后的指令,就可以遍历集合。

二 迭代器的使用

迭代器通常被称为轻量级对象;创建它的代价小,因此,经常可以看到对迭代器有些奇怪的限制,例如,Java的Iterator只能单向移动,这个Iterator只能用来:

  • 使用方法iterator()要求集合返回一个Iterator,Iterator将准备好返回集合的第一个元素;
  • 使用next()获取集合中的下一个元素;
  • 使用hasNext()检查集合中是否还存在元素;
  • 使用remove()将迭代器新近返回的元素删除;

1、Iterator接口

为了观察它的工作方式,让我们来看一个例子:

import java.util.*;

public class SimpleIteration {
    public static void main(String[] args) {
        //默认从小到大排序
        List<Person> pers = new ArrayList<Person>();

        Person p1 = new Person("吴定会",50,true);
        pers.add(p1);

        Person p2 = new Person("沈艳霞",46,false);
        pers.add(p2);

        Person p3 = new Person("张三",17,true);
        pers.add(p3);

        Person p4 = new Person("李四",34,false);
        pers.add(p4);

        Iterator<Person> it = pers.iterator();
        //检查list中是否还有元素
        while(it.hasNext()) {
            //获取list中下一个元素
            Person p = it.next();
            System.out.print(p + "  ");
        }
        System.out.println();

        it = pers.iterator();
        for(int i=0;i<4;i++) {
            //获取list中下一个元素
            it.next();
            //将迭代器新近返回的元素删除
            it.remove();
            System.out.println(i + ":" + pers);
        }
        System.out.print(pers);

    }
}

输出结果如下:

吴定会-50-true  沈艳霞-46-false  张三-17-true  李四-34-false
0:[沈艳霞-46-false, 张三-17-true, 李四-34-false]
1:[张三-17-true, 李四-34-false]
2:[李四-34-false]
3:[]
[]

现在考虑创建一个display()方法,它不必知晓集合的确切类型:

import java.util.*;

public class CrossContainerIteration {
    public static void display(Iterator<Person> it) {
        while(it.hasNext()) {
            Person p = it.next();
            System.out.print(p + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ArrayList<Person> pers = new ArrayList<Person>();
        Person p1 = new Person("吴定会",50,true);
        pers.add(p1);

        Person p2 = new Person("沈艳霞",46,false);
        pers.add(p2);

        Person p3 = new Person("张三",17,true);
        pers.add(p3);

        Person p4 = new Person("李四",34,false);
        pers.add(p4);

        LinkedList<Person> persLL = new LinkedList<Person>(pers);
        HashSet<Person> persHS = new HashSet<Person>(pers);        

        display(pers.iterator());
        display(persLL.iterator());
        display(persHS.iterator());
    }
}

输出:

吴定会-50-true 沈艳霞-46-false 张三-17-true 李四-34-false
吴定会-50-true 沈艳霞-46-false 张三-17-true 李四-34-false
张三-17-true 吴定会-50-true 沈艳霞-46-false 李四-34-false

可以看到display()方法不包含任何有关它所遍历的集合的类型信息,而这也展示了Iterator的真正威力,能够将遍历集合的操作与集合底层结构分离。正因为如此,我们有时才会说,迭代器统一了对集合的访问方式。

2、ListIterator

ListIterator是一个更加强大的Iterator的子类型,它只能用于各种List类的访问,尽管Iterator只能向前移动,但是ListIterator可以双向移动。它还可以产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引,并且可以使用set()方法替代它访问过的最后一个元素。可以通过调用listIterrator()方法产生一个指向List开始处的ListIterator,并且还可以通过调用listIterator(n)方法创建一个一开始指向列表索引为n的元素处的ListIterator。下面的示例演示了所有这些能力:

import java.util.*;

public class ListIteration {
    public static void main(String[] args) {
        List<Person> pers = new ArrayList<Person>();
        Person p1 = new Person("吴定会",50,true);
        pers.add(p1);

        Person p2 = new Person("沈艳霞",46,false);
        pers.add(p2);

        Person p3 = new Person("张三",17,true);
        pers.add(p3);

        Person p4 = new Person("李四",34,false);
        pers.add(p4);

        //从前向后遍历
        ListIterator<Person> it = pers.listIterator();
        while(it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();

        //从后向前遍历
        while(it.hasPrevious()) {
            System.out.print(it.previous() + " ");
        }
        System.out.println();
        System.out.println(pers);

        //创建一个开始指向第三个索引元素处的ListIterator
        it = pers.listIterator(3);
        while(it.hasNext()) {
            System.out.println(it.next());
                        //替换在列表中从位置3开始向前的所有Person对象
            it.set(p1);
        }
        System.out.println(pers);
    }
}

输出:

吴定会-50-true 沈艳霞-46-false 张三-17-true 李四-34-false
李四-34-false 张三-17-true 沈艳霞-46-false 吴定会-50-true
[吴定会-50-true, 沈艳霞-46-false, 张三-17-true, 李四-34-false]
李四-34-false
[吴定会-50-true, 沈艳霞-46-false, 张三-17-true, 吴定会-50-true]

三 迭代器的实现

1、下面让我们看看Java中的Iterator接口是如何实现的

在Java中Iterator为一个接口,它只提供了迭代的基本规则。在JDK中它是这样定义的:对Collection进行迭代的迭代器。迭代器取代了Java Collection Framework中的Enumeration。迭代器与枚举有两点不同:

  • 迭代器在迭代期间可以从集合中移除元素。
  • 方法名得到了改进,Enumeration的方法名称都比较长。

其接口定义如下:

package java.util;
public interface Iterator<E> {
    boolean hasNext();//判断是否存在下一个对象元素

    E next();//获取下一个元素

    void remove();//移除元素
}

2、Iterable

Java中还提供了一个Iterable接口,Iterable接口实现后的功能是返回一个迭代器,我们常用的实现了该接口的子接口有:Collection<E>、List<E>、Set<E>等。该接口的iterator()方法返回一个标准的Iterator实现。实现Iterable接口允许对象成为foreach语句的目标。就可以通过foreach语句来遍历你的底层序列。

Iterable接口包含一个能产生Iterator对象的方法,并且Iterable被foreach用来在序列中移动。因此如果创建了实现Iterable接口的类,都可以将它用于foreach中。

Iterable接口的具体实现:

Package java.lang;

import java.util.Iterator;
public interface Iterable<T> {
    Iterator<T> iterator();
}

使用迭代器遍历集合:

public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("张三1");
        list.add("张三2");
        list.add("张三3");
        list.add("张三4");

        List<String> linkList = new LinkedList<String>();
        linkList.add("link1");
        linkList.add("link2");
        linkList.add("link3");
        linkList.add("link4");

        Set<String> set = new HashSet<String>();
        set.add("set1");
        set.add("set2");
        set.add("set3");
        set.add("set4");
        //使用迭代器遍历ArrayList集合
        Iterator<String> listIt = list.iterator();
        while(listIt.hasNext()){
            System.out.println(listIt.next());
        }
        //使用迭代器遍历Set集合
        Iterator<String> setIt = set.iterator();
        while(setIt.hasNext()){
            System.out.println(listIt.next());
        }
        //使用迭代器遍历LinkedList集合
        Iterator<String> linkIt = linkList.iterator();
        while(linkIt.hasNext()){
            System.out.println(listIt.next());
        }
}

使用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异常。

List<String> list = new ArrayList<String>();
        list.add("张三1");
        list.add("张三2");
        list.add("张三3");
        list.add("张三4");

        //使用迭代器遍历ArrayList集合
        Iterator<String> listIt = list.iterator();
        while(listIt.hasNext()){
            Object obj = listIt.next();
            if(obj.equals("张三3")){
                list.remove(obj);
            }
        }

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

Iterator的实现源码:  

private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

通过查看源码发现原来检查并抛出异常的是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较快。

参考文献:

[1] Java编程思想

[2] 深入理解Java中的迭代器(部分转载)

Java基础 -- 深入理解迭代器的更多相关文章

  1. Java基础之理解Annotation(与@有关,即是注释)

    Java基础之理解Annotation 一.概念 Annontation是Java5开始引入的新特征.中文名称一般叫注解.它提供了一种安全的类似注释的机制,用来将任何的信息或元数据(metadata) ...

  2. Java基础 -- 深入理解泛型

    一般的类和方法,只能使用具体的类型:要么是基本类型,要么是自定义的类.如果要编写可以应用于多种类型的代码,这种刻板的限制对代码的束缚就会很大. 而泛型很好的解决了这个问题,这也是Java SE5的重大 ...

  3. Java基础---集合框架---迭代器、ListIterator、Vector中枚举、LinkedList、ArrayList、HashSet、TreeSet、二叉树、Comparator

    为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式. 数组和集合类同是容器,有何不同? 数组虽然也可以存储对 ...

  4. Java基础 -- 深入理解Java类型信息(Class对象)与反射机制

    一 RTTI概念 认识Claa对象之前,先来了解一个概念,RTTI(Run-Time Type Identification)运行时类型识别,对于这个词一直是 C++ 中的概念,至于Java中出现RT ...

  5. Java基础 -- 深入理解Java异常机制

    异常指不期而至的各种状况,如:文件找不到.网络连接失败.非法参数等.异常是一个事件,它发生在程序运行期间,干扰了正常的指令流程.Java通 过API中Throwable类的众多子类描述各种不同的异常. ...

  6. Java基础之理解Annotation

    一.概念 Annontation是Java5开始引入的新特征.中文名称一般叫注解.它提供了一种安全的类似注释的机制,用来将任何的信息或元数据(metadata)与程序元素(类.方法.成员变量等)进行关 ...

  7. JAVA基础——集合Iterator迭代器的实现

    一.迭代器概述 1.什么是迭代器? 在Java中,有很多的数据容器,对于这些的操作有很多的共性.Java采用了迭代器来为各种容器提供了公共的操作接口.这样使得对容器的遍历操作与其具体的底层实现相隔离, ...

  8. JAVA基础之理解JNI原理

    JNI是JAVA标准平台中的一个重要功能,它弥补了JAVA的与平台无关这一重大优点的不足,在JAVA实现跨平台的同时,也能与其它语言(如C.C++)的动态库进行交互,给其它语言发挥优势的机会. 有了J ...

  9. Java基础——深入理解Java中的final关键字(转载)

    Java中的final关键字非常重要,它可以应用于类.方法以及变量.这篇文章中我将带你看看什么是final关键字?将变量,方法和类声明为final代表了什么?使用final的好处是什么?最后也有一些使 ...

随机推荐

  1. RapidXML 试用

    近半年来断断续续的封装一些SDK,在兼顾跨平台.易用性和高效率上还要顾及到对外dll的大小问题.由于之前解析SVG文件的用到了一个XML解析库xercesc,这个DLL实在巨大近4M,于是尝试用新的X ...

  2. 20161007 NOIP 模拟赛 T1 解题报告

    排序 3.1 题意描述 众所周知,熟练掌握至少一种排序算法是参加NOIP的必备技能.常见的排序算法有冒泡 排序.归并排序.快速排序.奇偶排序.猴子排序.梳排序.鸡尾酒排序.臭皮匠排序等. 在这里,介绍 ...

  3. AP聚类算法(Affinity propagation Clustering Algorithm )

    AP聚类算法是基于数据点间的"信息传递"的一种聚类算法.与k-均值算法或k中心点算法不同,AP算法不需要在运行算法之前确定聚类的个数.AP算法寻找的"examplars& ...

  4. 关于call和apply的那点事儿

    在JavaScript中改变闭包中的this关键字中经常用到的就是call和apply了 首先:call和apply的作用的区别是什么? 答:call和apply 的作用是相同的.都是用来改变函数th ...

  5. Netty高并发原理

        Netty是一个高性能 事件驱动的异步的非堵塞的IO(NIO)框架,用于建立TCP等底层的连接,基于Netty可以建立高性能的Http服务器.支持HTTP. WebSocket .Protob ...

  6. Java中Map的使用

    Map以按键/数值对的形式存储数据,和数组很类似,在数组中存在的索引,它们本身也是对象.       Map的接口       Map---实现Map       Map.Entry--Map的内部类 ...

  7. 用IO流拷贝歌曲

    package lianxi; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOEx ...

  8. Hibernate异常之cascade

    org.hibernate.MappingException: Unsupported cascade style: delete-option at org.hibernate.engine.spi ...

  9. python使用随机的163账号发送邮件

    import linecache import smtplib import time import linecache import random #算出txt的行数,163账号_2.txt中,每一 ...

  10. MyBatis3系列__Demo地址

    一直光写博客了,并且感觉贴代码有点麻烦,但是以后的博客也尽量说的清楚,此外,觉得贴一下demo会好一些: 当然了,需要能够FQ哈,如果不能FQ的话建议百度或者参考这个:https://secure.s ...