ArrayList中Iterator的研究学习

Posted 2020-08-10 MrPour

       最近去某公司面试，被问到了一个简单的问题，ArrayList中要删除一些元素应该怎么操作？答曰："使用Iterator迭代器遍历，判断之后再用迭代器提供的remove()方法将判断为true的元素删掉"，问：“为什么要选择这个方法？”答曰：“迭代器采用的是fail-fast机制，foreach循环内部调用了迭代器，删除元素破坏了集合的结构，所以会报错”，追问：“为什么不能用for循环呢？没使用迭代器也应该可行啊？为什么迭代器又是可以的呢？” 答曰：“因为for循环删掉元素后会错位，至于迭代器是怎么解决这个问题的， 还真不知道...” 

       作为一名菜鸟，招架不了这么连珠炮般的提问，于是回去读了一遍关于Iterator的源码，简要的解析一番。本次学习过程大概是围绕这几个问题展开的：

 

       1、Iterator和Iterable的关系

         Iterator是java中的一个接口，定义了一系列方法。诸如hasNext()判定、next()取下一元素的值和remove()删除当前元素值。

         Iterable是java中的一个接口，定义了一个Iterator的实现类作为成员变量，也提供了for-each这个语法糖。

            

        正如它们的英文意思，Iterator规定了作为一个迭代器应该具有的方法，而Iterable则是规定了如果一个类可以被迭代，不仅要自己实现属于自己的迭代器，而且还附送一个for-each语法糖给程序员作为快捷手段。

   

         2、fail-fast机制   

• 什么是fail-fast？

      The iterators returned by this class‘s {@link #iterator() iterator} and
 * {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:</a>
 * if the list is structurally modified at any time after the iterator is
 * created, in any way except through the iterator‘s own
 * {@link ListIterator#remove() remove} or
 * {@link ListIterator#add(Object) add} methods, the iterator will throw a
 * {@link ConcurrentModificationException}.  Thus, in the face of
 * concurrent modification, the iterator fails quickly and cleanly, rather
 * than risking arbitrary, non-deterministic behavior at an undetermined
 * time in the future.

 

       这个官方解释已经非常明白了：为防止并发(可以理解为一切Iterator体系之外的方法)修改，迭代器一旦被调出来之后，任何除了Iterator类中定义的方法以外的方法(包括集合的clear、remove和add方法)，对集合元素进行修改，都属于结构化的改变(无论是别的线程还是自己的线程)，迭代器就会抛出ConcurrentModificationException的错误。这里的结构改变，确切的说指的是集合的size发生变化。(注意：并非是elementData这个数组的length发生改变，因为数组中的元素完全可以为null，length不变，而集合中这个元素删掉了，size就得减1)。

 

• 为什么会报错？

                  在这里就不贴代码了，直接上结果：

• ArrayList提供了一个成员变量modCount，这个变量表示整个list被结构化修改的次数，初始值为0。
• ArrayList的remove、add、clear方法执行的时候，内部会执行modCount++
• ArrayList中的迭代器中提供一个成员变量expectedModCount，初始值为modCount，记录在迭代器被创建时的集合结构改变的次数。
• 迭代器的next、remove方法在执行之前都会调用checkForModification方法判定expectedModCount与modCount之间是否相等，如果不相等，则抛出concurrentModificationException

                  这就可以解释为什么for-each不能在内部使用集合的删除方法了——因为它底层调用了Iterator的next方法进行遍历。

             

          3、为什么Iterator.remove()不会出现错位？

                  这也是Iterator设计的精髓所在。       

        private class Itr implements Iterator<E> {
        int cursor;       // 即将取出的元素的角标
        int lastRet = -1; // 上一次取出的元素的角标

        int expectedModCount = modCount;       // Iterator创建时的改动初始值
        public boolean hasNext() {
            return cursor != size;      //判断是否还有下一位元素存在，该方法要实现持续遍历判断，必须要配合next()方法
        }

        @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;                       // 更新cursor的值为下一轮判定做准备
            return (E) elementData[lastRet = i];  // 给lastRet赋值，否则remove()方法报错
        }

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

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;    //对cursor进行修正
                lastRet = -1;       //remove()方法不能连续执行，因为lastRet不合法，只能先执行next()
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

• 将迭代器设计成内部类

         因为迭代器需要实现接口中操作对象的方法，而不同的对象其底层数据结构不同，因此迭代器的实现类需要根据对象的特点进行设计，也就是说迭代器只有在相应的对象中才有用，不如就在其内部定义得了。

• 三个方法的全家桶

• • hasNext()方法

                    取cursor与size进行对比，用来判断是否还能继续遍历下去。

            当cursor=size的时候，后续方法不管是next()遍历取值还是remove()删除都因为超界不能继续，所以此时判定依然没任何意义。

• • next()方法

             这个方法很简单，最终返回的即是elementData[lastRet]这个元素，即把当前的cursor对应的数据取出。值得注意的是：

• • 在每次该方法执行的逻辑尾部cursor=cursor+1——使得hasNext()的遍历得以继续下去。
  • 方法中引入了中间变量i，提前将cursor的值赋给i后，返值时又将i赋给lastRet——使得remove()顺利实现。

• remove()方法

• • • 首先判定lastRet<0是否成立，如果成立则报错。Iterator强制我们在使用remove()方法之前要先进行next()方法为lastRet赋值，否则lastRet=-1，永远都是错误。
    • 在next()调用之后，lastRet被赋值上了cursor，调用ArrayList.this.remove(lastRet)的方法删掉对应的元素，完成删除。
    • 删除已经完成，再次将cursor=lastRet，最后lastRet=-1，为什么要设计成这样？

a、如果在遍历中删除元素，会重新创建底层数组，把旧数组的值拷贝到新的数组中，后续的元素全部进一位，这样原先next()中执行cursor=cursor+1的逻辑就乱套了，因为再次执行next()和remove()的时候我们会错过cursor位置的元素。因此，cursor也需要在每一次执行删除后得到修正，即cursor=lastRet，目的就是不要发生自增。

b、这里把lastRet设为-1的目的是为了阻止程序员在没有进行next()的情况下连续去remove()，只有再次执行next()之后，lastRet完成刷新，remove()方法才知道应该删除哪个元素。

 

             这就解释了Iterator.remove()不会出现删除元素错位的现象，即若上次执行了删除，下次删除的仍是该位置的元素。      

          

 

   4、总结

• Iterator提供了一整套精密的流程，确保整个删除、取值的逻辑正确，环环相扣，缺了每一步都可能出错。

        hasNext()的目的是判定循环是否超界，next()的目的是提供向下取值，通过cursor=cursor+1相联系，两者组合即替代了传统的for循环遍历。

         next()和remove()也是按照顺序去执行的，通过lastRet=cursor、lastRet=-1和lastRet=i相联系的，两者组合确保了remove()方法顺利进行。 这三个方法就像齿轮一样，一环扣一环，非常精妙的设计。

•  可以从迭代器的角度来证明ArrayList、Vector这些继承了 AbstractList的集合是非线程安全的。

         因为modCount这个成员变量存放了信息，所以不是线程安全的。试想多个线程都用迭代器去操作同一个对象，modCount发生改变，其余线程的迭代操作也会报错。