【大数据】学习笔记 1 Java SE 第11章集合与迭代器 11.2 Iterator迭代器

客官°小女子只卖身不卖艺 2024-03-22 12:19 51阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第11章 集合与迭代器
             *   *  11.2 Iterator迭代器
                 *   *  11.2.1 Iterator接口
                     *  11.2.2 迭代器的实现原理
                     *  11.2.3 使用Iterator迭代器删除元素
                     *  11.2.4 Iterator迭代器的快速失败（fail-fast）机制

![在这里插入图片描述][f71723f56ba64e2b92e3cf412130ddd6.png_pic_center]

#### 1 Java SE ####

##### 第11章 集合与迭代器 #####

###### 11.2 Iterator迭代器 ######

###### 11.2.1 Iterator接口 ######

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口`java.util.Iterator`。`Iterator`接口也是Java集合中的一员，但它与`Collection`、`Map`接口有所不同，`Collection`接口与`Map`接口主要用于存储元素，而`Iterator`主要用于迭代访问（即遍历）`Collection`中的元素，因此`Iterator`对象也被称为迭代器。

想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法：

*  `public Iterator iterator()`: 获取集合对应的迭代器，用来遍历集合中的元素的。

下面介绍一下迭代的概念：

*  **迭代**：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

Iterator接口的常用方法如下：

*  `public E next()`:返回迭代的下一个元素。
 *  `public boolean hasNext()`:如果仍有元素可以迭代，则返回 true。

接下来我们通过案例学习如何使用Iterator迭代集合中元素：

package com.dingjiaxiong.iterator;
    
    import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestIterator
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 19:28
     */
    
    public class TestIterator {
        
        @Test
        public void test01() {
        
            Collection coll = new ArrayList();
            coll.add("小李广");
            coll.add("扫地僧");
            coll.add("石破天");
    
            Iterator iterator = coll.iterator();
            System.out.println(iterator.next());
            System.out.println(iterator.next());
            System.out.println(iterator.next());
            System.out.println(iterator.next());
        }
    
        @Test
        public void test02() {
        
            Collection coll = new ArrayList();
            coll.add("小李广");
            coll.add("扫地僧");
            coll.add("石破天");
    
            Iterator iterator = coll.iterator();//获取迭代器对象
            while (iterator.hasNext()) {
        //判断是否还有元素可迭代
                System.out.println(iterator.next());//取出下一个元素
            }
        }
    }

![在这里插入图片描述][ddfc41ceb23a4e40a7cf9eb9f72328f0.png_pic_center]

![在这里插入图片描述][bf83c78098084d18b6b043727212e1eb.png_pic_center]

> 提示：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

###### 11.2.2 迭代器的实现原理 ######

我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时，首先通过调用集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，为了让初学者能更好地理解迭代器的工作原理，接下来通过一个图例来演示Iterator对象迭代元素的过程：

![在这里插入图片描述][e5f2539c1dde497696cca87633425d1d.png_pic_center]

在调用Iterator的next方法之前，迭代器指向第一个元素，当第一次调用迭代器的next方法时，返回第一个元素，然后迭代器的索引会向后移动一位，指向第二个元素，当再次调用next方法时，返回第二个元素，然后迭代器的索引会再向后移动一位，指向第三个元素，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

###### 11.2.3 使用Iterator迭代器删除元素 ######

java.util.Iterator迭代器中有一个方法：

void remove() ;

那么，既然Collection已经有remove(xx)方法了，为什么Iterator迭代器还要提供删除方法呢？

因为在JDK1.8之前Collection接口没有removeIf方法，即无法根据条件删除。

例如：要删除以下集合元素中的偶数

package com.dingjiaxiong.iterator;
    
    import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestIteratorRemove
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 19:30
     */
    
    public class TestIteratorRemove {
        
        @Test
        public void test01() {
        
            Collection coll = new ArrayList();
            coll.add(1);
            coll.add(2);
            coll.add(3);
            coll.add(4);
    
    //		coll.remove(?)//没有removeIf方法无法实现删除“偶数”
    
            Iterator iterator = coll.iterator();
            while (iterator.hasNext()) {
        
                Integer element = (Integer) iterator.next();
                if (element % 2 == 0) {
        
                    iterator.remove();
                }
            }
            System.out.println(coll);
        }
    }

![在这里插入图片描述][b205a07f091f4fa5adfa2847e82264fe.png_pic_center]

###### 11.2.4 Iterator迭代器的快速失败（fail-fast）机制 ######

如果在Iterator、ListIterator迭代器创建后的任意时间从结构上修改了集合（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。

这样设计是因为，迭代器代表集合中某个元素的位置，内部会存储某些能够代表该位置的信息。当集合发生改变时，该信息的含义可能会发生变化，这时操作迭代器就可能会造成不可预料的事情。因此，果断抛异常阻止，是最好的方法。这就是Iterator迭代器的快速失败（fail-fast）机制。

【1】ConcurrentModificationException异常

package com.dingjiaxiong.iterator;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestConcurrentModificationException
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 19:31
     */
    
    public class TestConcurrentModificationException {
        
        public static void main(String[] args) {
        
            Collection coll = new ArrayList();
            coll.add("hello");
            coll.add("world");
            coll.add("java");
            coll.add("haha");
            coll.add("mysql");
    
            Iterator iterator = coll.iterator();
            while (iterator.hasNext()) {
        
                String str = (String) iterator.next();
                if (str.contains("a")) {
        
                    coll.remove(str);//foreach遍历集合过程中，调用集合的remove方法
                }
            }
    
            /*for (Object o : coll) {
                String str = (String) o;
                if(str.contains("a")){
                    coll.remove(o);//foreach遍历集合过程中，调用集合的remove方法
                }
            }*/
        }
    }

![在这里插入图片描述][83b15961913b4b0b9259425297d19a92.png_pic_center]

【2】modCount变量

那么迭代器如何实现快速失败（fail-fast）机制的呢？

*  在ArrayList等集合类中都有一个modCount变量。它用来记录集合的结构被修改的次数。
 *  当我们给集合添加和删除操作时，会导致modCount++。
 *  然后当我们用Iterator迭代器遍历集合时，创建集合迭代器的对象时，用一个变量记录当前集合的modCount。例如：`int expectedModCount = modCount;`，并且在迭代器每次next()迭代元素时，都要检查 `expectedModCount != modCount`，如果不相等了，那么说明你调用了Iterator迭代器以外的Collection的add,remove等方法，修改了集合的结构，使得modCount++，值变了，就会抛出ConcurrentModificationException。

下面以AbstractList和ArrayList.Itr迭代器为例进行源码分析：

AbstractList类中声明了modCount变量：

/**
 * The number of times this list has been structurally modified.
 * Structural modifications are those that change the size of the
 * list, or otherwise perturb it in such a fashion that iterations in
 * progress may yield incorrect results.
 *
 * This field is used by the iterator and list iterator implementation
 * returned by the {@code iterator} and {@code listIterator} methods.
 * If the value of this field changes unexpectedly, the iterator (or list
 * iterator) will throw a {@code ConcurrentModificationException} in
 * response to the {@code next}, {@code remove}, {@code previous},
 * {@code set} or {@code add} operations. This provides
 * fail-fast behavior, rather than non-deterministic behavior in
 * the face of concurrent modification during iteration.
 *
 * Use of this field by subclasses is optional. If a subclass
 * wishes to provide fail-fast iterators (and list iterators), then it
 * merely has to increment this field in its {@code add(int, E)} and
 * {@code remove(int)} methods (and any other methods that it overrides
 * that result in structural modifications to the list). A single call to
 * {@code add(int, E)} or {@code remove(int)} must add no more than
 * one to this field, or the iterators (and list iterators) will throw
 * bogus {@code ConcurrentModificationExceptions}. If an implementation
 * does not wish to provide fail-fast iterators, this field may be
 * ignored.
 */
 protected transient int modCount = 0;

modCount是这个list被结构性修改的次数。子类使用这个字段是可选的，如果子类希望提供fail-fast迭代器，它仅仅需要在add(int, E),remove(int)方法（或者它重写的其他任何会结构性修改这个列表的方法）中添加这个字段。调用一次add(int,E)或者remove(int)方法时必须且仅仅给这个字段加1，否则迭代器会抛出伪装的ConcurrentModificationExceptions错误。如果一个实现类不希望提供fail-fast迭代器，则可以忽略这个字段。

Arraylist的Itr迭代器：

private class Itr implements Iterator<E> {
 
 int cursor; 
 int lastRet = -1; 
 int expectedModCount = modCount;//在创建迭代器时，expectedModCount初始化为当前集合的modCount的值
 
 public boolean hasNext() {
 
 return cursor != size;
 }
 
 @SuppressWarnings("unchecked")
 public E next() {
 
 checkForComodification();//校验expectedModCount与modCount是否相等
 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];
 }
 	final void checkForComodification() {
 
 if (modCount != expectedModCount)//校验expectedModCount与modCount是否相等
 throw new ConcurrentModificationException();//不相等，抛异常
 }
 }

ArrayList的remove方法：

public boolean remove(Object o) {
 
 if (o == null) {
 
 for (int index = 0; index < size; index++)
 if (elementData[index] == null) {
 
 fastRemove(index);
 return true;
 }
 } else {
 
 for (int index = 0; index < size; index++)
 if (o.equals(elementData[index])) {
 
 fastRemove(index);
 return true;
 }
 }
 return false;
 }
 
 
 private void fastRemove(int index) {
 
 modCount++;
 int numMoved = size - index - 1;
 if (numMoved > 0)
 System.arraycopy(elementData, index+1, elementData, index,
 numMoved);
 elementData[--size] = null; // clear to let GC do its work
 }

![在这里插入图片描述][0ebe0b6293944609aa4626e8b0dab9c9.png_pic_center]

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 `ConcurrentModificationException`。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。例如：

package com.dingjiaxiong.iterator;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestNoConcurrentModificationException
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 19:34
     */
    
    public class TestNoConcurrentModificationException {
        
        public static void main(String[] args) {
        
            Collection coll = new ArrayList();
            coll.add("hello");
            coll.add("world");
            coll.add("java");
            coll.add("haha");
    
            Iterator iterator = coll.iterator();
            while (iterator.hasNext()) {
        
                String str = (String) iterator.next();
                if (str.contains("a")) {
        
                    coll.remove(str);
                    //Iterator遍历集合过程中，调用集合的remove方法
                }
            }
        }
    }

![在这里插入图片描述][3c9173e22f0a4883a846eacb57a5e184.png_pic_center]

![在这里插入图片描述][ae0a86ee231e452fa013f29644093cbb.png_pic_center]

[f71723f56ba64e2b92e3cf412130ddd6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/22ed6bef21ad4cfc873919d17e4c25d8.png
[ddfc41ceb23a4e40a7cf9eb9f72328f0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/a03cd86854344f729e9f7eb281d63ff4.png
[bf83c78098084d18b6b043727212e1eb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/074d97d99ac04ce4912ec1c9c517b2f3.png
[e5f2539c1dde497696cca87633425d1d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/be56da87d1bb44ddb3b44a0432fa3f34.png
[b205a07f091f4fa5adfa2847e82264fe.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/6fa25e5742b54e37a2657ebf4386f6e2.png
[83b15961913b4b0b9259425297d19a92.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/0509f6c6a29a4860b665e72308577968.png
[0ebe0b6293944609aa4626e8b0dab9c9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/83cd98a01bf94e1dbb373be522b5a1a6.png
[3c9173e22f0a4883a846eacb57a5e184.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ebacf449ae9942ad9d62dafacdfa4263.png
[ae0a86ee231e452fa013f29644093cbb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f4d2faa9083447f0beebc3841d1a6388.png