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

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

上图中，在调用Iterator的next()方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next()方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next()方法时，迭代器的索引会指向第二个元素并将该元素返回，以此类推，直到hasNext()方法返回false，表示到达了集合的末尾，终止对元素的遍历。

常用方法：

boolean hasNext(): 判断集合中是否还有下一个元素，如果有则返回true，否则返回false。
E next(): 返回迭代器中的下一个元素，并将迭代器的指针向后移动一位。如果没有下一个元素，则抛出NoSuchElementException异常。
void remove(): 从集合中删除迭代器最后一次返回的元素。注意，该方法只能在调用next方法之后且尚未再次调用remove方法时才能调用。如果在调用remove方法之前没有调用过next方法，或者在上一次调用next方法之后又调用了remove方法，则会抛出IllegalStateException异常。

Iterator接口提供了基本的遍历功能，可以通过循环结构配合使用hasNext和next方法来遍历集合中的元素。同时，可以使用remove方法在遍历过程中删除特定元素。

注意：

通过迭代器获取ArrayList集合中的元素时，这些元素的类型都是Object类型，如果想获取到特定类型的元素，则需要进行对数据类型强制转换。
在使用Iterator迭代集合时，避免直接在迭代期间修改集合结构，以免触发ConcurrentModificationException异常。

扩展小知识:

ConcurrentModificationException异常表示在迭代器运行期间，通过集合对象对集合进行了结构性修改（如添加或删除元素），导致迭代器的预期迭代次数与实际迭代次数不一致，从而抛出异常。

这个异常通常发生在使用普通的Iterator进行迭代时，而不是使用并发安全的迭代器（如ConcurrentHashMap的迭代器）。当你使用普通的Iterator进行迭代时，是不能在迭代过程中直接对集合进行结构性修改的，否则就会触发ConcurrentModificationException异常。

解决此异常的方法有两种：

使用Iterator的remove()方法：可以在迭代过程中调用Iterator的remove()方法来删除元素，它是唯一能够在迭代期间安全删除元素的方法。示例代码如下：


Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if (condition to remove element) {
        iterator.remove(); // 删除当前元素，不会抛出异常
    }
}

使用并发安全的集合类：如果需要在迭代期间对集合进行修改操作，可以考虑使用并发安全的集合类，如CopyOnWriteArrayList、ConcurrentHashMap等。这些集合类提供了迭代器的安全性，并且允许在迭代期间进行修改操作。

所以，在使用Iterator迭代集合时，避免直接在迭代期间修改集合结构，以免触发ConcurrentModificationException异常。如果需要修改集合，请使用Iterator的remove()方法或并发安全的集合类来确保迭代器的正确性。

异步迭代器（Asynchronous Iterator）：

异步迭代器是一种非阻塞式的迭代器，它在处理当前元素时不会等待操作完成而立即返回下一个元素。异步迭代器通常采用回调函数、事件通知或其他机制来进行处理结果的通知。

在使用异步迭代器进行遍历时，调用next()方法会立即返回下一个元素，并且可能会触发异步处理操作。迭代器会在后台或其他线程中进行元素的处理，当处理完成时，通过回调函数或事件通知机制将结果通知给使用者。

异步迭代器的优点是可以提高遍历效率和并发性能，因为它不需要等待当前元素的处理完成。这在多线程环境、异步编程或需要处理耗时操作的场景中非常有用。

常用的方法

next(): 获取异步迭代器的下一个元素。此方法会返回一个CompletableFuture对象，我们可以通过该对象来获取异步操作的结果。
hasNext(): 判断异步迭代器是否还有下一个元素。返回一个CompletableFuture<Boolean>对象，用于表示是否存在下一个元素。
forEachRemaining(action): 对剩余的元素执行给定的操作，直到所有元素都已处理完毕或遇到异常。
tryAdvance(action): 尝试对下一个元素执行给定的操作。如果存在下一个元素，则对其执行操作并返回true，否则返回false。
close(): 关闭异步迭代器，释放相关资源。在使用完异步迭代器后，应该及时调用该方法以避免资源泄露。

注意：

同步迭代器和异步迭代器的选择要根据具体的需求和场景来决定。同步迭代器适合保证遍历顺序和单线程环境，而异步迭代器适合提高遍历效率和并发性能，但可能需要额外的异步处理机制。

总结：

同步迭代器是阻塞式的，等待当前元素处理完成后再返回下一个元素；异步迭代器是非阻塞式的，在处理当前元素时不等待操作完成而立即返回下一个元素，并通过回调或事件通知机制进行结果通知。在Java中，常见的迭代器是同步迭代器，但可以根据需要自定义或使用第三方库实现异步迭代器的功能。

代码示例

示例一：

同步迭代器代码示例（使用Iterator接口）：


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个空的列表
        List<String> list = new ArrayList<>();
        // 添加元素到列表
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        // 获取集合的迭代器
        Iterator<String> iterator = list.iterator();
 
        // 循环遍历集合中的元素
        while (iterator.hasNext()) {
            // 获取下一个元素并移动迭代器指针
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

示例二：

异步迭代器代码示例：


import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
 
// 自定义异步迭代器接口
interface AsyncIterator<T> {
    CompletableFuture<Boolean> hasNext(); // 异步判断是否存在下一个元素
    CompletableFuture<T> next(); // 异步获取下一个元素
    void close(); // 关闭迭代器，释放资源
}
 
// 异步迭代器实现类
class SimpleAsyncIterator<T> implements AsyncIterator<T> {
    private final T[] elements; // 数据序列
    private int currentIndex; // 当前索引
 
    public SimpleAsyncIterator(T[] elements) {
        this.elements = elements;
        this.currentIndex = 0;
    }
 
    @Override
    public CompletableFuture<Boolean> hasNext() {
        return CompletableFuture.completedFuture(currentIndex < elements.length); // 完成时返回是否还有下一个元素的结果
    }
 
    @Override
    public CompletableFuture<T> next() {
        T element = elements[currentIndex]; // 获取当前元素
        currentIndex++; // 索引自增
        return CompletableFuture.completedFuture(element); // 完成时返回当前元素
    }
 
    @Override
    public void close() {
        // 可以在此释放相关资源
    }
}
 
public class Main {
    public static void main(String[] args) {
        // 创建数据序列
        Integer[] numbers = {1, 2, 3, 4, 5};
 
        // 创建异步迭代器
        AsyncIterator<Integer> iterator = new SimpleAsyncIterator<>(numbers);
 
        // 创建线程池
        Executor executor = Executors.newFixedThreadPool(2);
 
        // 异步遍历和处理数据序列
        CompletableFuture.runAsync(() -> {
            while (true) {
                CompletableFuture<Boolean> hasNextFuture = iterator.hasNext();
 
                // 异步获取是否存在下一个元素
                hasNextFuture.thenCompose(hasNext -> {
                    if (hasNext) {
                        // 异步获取下一个元素并处理
                        CompletableFuture<Integer> nextFuture = iterator.next();
                        nextFuture.thenAcceptAsync(Main::processData, executor);
                    } else {
                        // 处理完所有元素后关闭迭代器
                        iterator.close();
                    }
                    return CompletableFuture.completedFuture(null);
                }).join(); // 阻塞等待完成
            }
        }, executor);
    }
 
    // 数据处理方法示例
    private static void processData(Integer data) {
        System.out.println("正在处理数据: " + data);
        // 具体的数据处理逻辑
    }
}

示例三：

综合同步迭代器和异步迭代器代码示例：


import java.util.Iterator;
import java.util.NoSuchElementException;
 
// 同步迭代器
class SynchronousIterator implements Iterator<Integer> {
    private int[] array;    // 存储数据的数组
    private int index;      // 当前迭代位置
 
    public SynchronousIterator(int[] array) {
        this.array = array;
        this.index = 0;
    }
 
    // 检查是否还有下一个元素
    @Override
    public boolean hasNext() {
        return index < array.length;    // 当前位置是否小于数组长度
    }
 
    // 返回下一个元素，并将迭代器指针向后移动一位
    @Override
    public Integer next() {
        if (hasNext()) {                // 如果还有下一个元素
            int element = array[index]; // 获取当前位置的元素
            index++;                    // 将迭代器指针向后移动一位
            return element;             // 返回当前元素
        }
        throw new NoSuchElementException();   // 抛出异常表示没有下一个元素
    }
}
 
// 异步迭代器
class AsynchronousIterator implements Iterator<Integer> {
    private int[] array;    // 存储数据的数组
    private int index;      // 当前迭代位置
 
    public AsynchronousIterator(int[] array) {
        this.array = array;
        this.index = 0;
    }
 
    // 检查是否还有下一个元素
    @Override
    public boolean hasNext() {
        // 在此处可以进行异步操作，例如请求远程数据或执行耗时任务
        // 返回 true 表示还有元素，返回 false 表示迭代结束
        return index < array.length;    // 当前位置是否小于数组长度
    }
 
    // 返回下一个元素，并将迭代器指针向后移动一位
    @Override
    public Integer next() {
        if (hasNext()) {                // 如果还有下一个元素
            int element = array[index]; // 获取当前位置的元素
            index++;                    // 将迭代器指针向后移动一位
            return element;             // 返回当前元素
        }
        throw new NoSuchElementException();   // 抛出异常表示没有下一个元素
    }
}
 
// 示例用法
public class Main {
    public static void main(String[] args) {
        int[] numbers = { 1, 2, 3, 4, 5 };   // 定义一个整数数组作为数据源
 
        // 同步迭代器示例
        Iterator<Integer> syncIterator = new SynchronousIterator(numbers);
        while (syncIterator.hasNext()) {         // 遍历迭代器中的元素
            Integer number = syncIterator.next(); // 获取当前元素
            System.out.println(number);           // 输出当前元素
        }
 
        // 异步迭代器示例
        Iterator<Integer> asyncIterator = new AsynchronousIterator(numbers);
        while (asyncIterator.hasNext()) {         // 遍历迭代器中的元素
            Integer number = asyncIterator.next(); // 获取当前元素
            System.out.println(number);            // 输出当前元素
        }
    }
}

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】