首页 > 其他分享> > Iterator接口(迭代器)

Iterator接口(迭代器)

2019-04-27 21:39:29 作者：互联网

前言
原理
方法
异常

Iterator接口(迭代器)

前言

一般遍历数组都是采用for循环或者增强for，这两个方法也可以用在集合框架，但是还有一种方法是采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或ListIterator接口。
迭代器，使你能够通过循环来得到或删除集合的元素。ListIterator 继承了Iterator，以允许双向遍历列表和修改元素。

原理

在获取迭代器的时候，会创建一个集合的副本。同时会创建一个指针指向迭代器迭代集合的其实位置。

方法

hasNext() ：该方法会判断集合对象是否还有下一个元素，如果已经是最后一个元素则返回false。
next()：把迭代器的指向移到下一个位置，同时，该方法返回下一个元素的引用。
remove() 从迭代器指向的集合中移除迭代器返回的最后一个元素。

public class Test{
     public static void main(String[] args) {
         List<String> list=new ArrayList<String>();
         list.add("Hello");
         list.add("World");
         list.add("HAHAHAHA");
         Iterator<String> ite = list.iterator();
         //判断下一个元素之后是否有值
         while(ite.hasNext()){ 
             System.out.println(ite.next());
         }
    }
}

异常

ConcurrentModificationException异常

异常名：并发修改异常
产生原因：在使用迭代器遍历集合元素的同时对集合元素进行了操作时抛出此异常
解决办法：
使用普通for循环遍历
使用List特有的迭代器遍历


public class Test {
    public static  void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("张三");
        c.add("李四");
        c.add("王五");
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            //必须是接收it.next(),不然会死循环。
            Object obj = it.next();
            String s = (String)obj;
            if(s.contains("李四")){
               // 最后会报ConcurrentModificationException异常
                c.add("王五");
            }
            System.out.println(s);
        }
    }
}

使用foreach也会出现同样的异常：

    }
        for (Object object : c) {
            String s = (String)object;
            if (s.contains("李四")) {
                c.add("王五");
            }
            System.out.println(s);
        }

因为foreach遍历的本质就是使用iterator迭代器遍历。

注意：

在迭代的时候是可以删除元素的。因为会使用iterator中的remove。
看一下ArrayList中iterator重写的源码就明白了。

源码：

 public Iterator<E> iterator() {
        return new Itr();
    }
    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();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

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

在ArrayList内部定义了一个内部类Itr，该类实现了Iterator接口。
　　在Itr中，有三个变量分别是
　　cursor：表示下一个元素的索引位置
　　lastRet：表示上一个元素的索引位置
　　expectModCount：预期被修改的次数

  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();
        }

在执行remove操作时，会先执行checkForComodification()，判断集合的修改次数是否合法，然后会执行ArrayList的remove()方法，该方法会将modCount值加1，这里我们将expectedModCount=modCount，使之保持统一。

iterator和for循环的区别：

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

以上

@Fzxey

标签：Iterator,迭代,lastRet,接口,public,new,ArrayList
来源： https://www.cnblogs.com/fzxey/p/10780510.html