java iterator 实现自定义集合遍历的核心是让你的类实现 iterable 接口,并返回一个实现了 iterator 接口的对象。具体做法是在自定义集合中定义一个内部类(或独立类)来实现 iterator,通过维护一个索引指针来追踪当前元素,并在 next() 和 hasnext() 方法中处理越界检查和状态更新。这样就能让自定义集合直接支持增强型 for 循环。

如何为自定义集合添加迭代器支持
要让自定义集合支持迭代,必须实现 java.lang.Iterable 接口。这要求你提供一个 iterator() 方法,该方法返回一个 java.util.Iterator 实例。通常的做法是在集合类内部定义一个私有静态内部类来实现 Iterator 接口,这样可以访问外部类的私有字段,如存储数据的数组或列表。在 next() 方法中,你需要先检查是否有下一个元素,然后返回当前元素并将索引加一;在 hasNext() 方法中,只需判断索引是否小于集合的大小。这种设计将遍历逻辑与集合的数据结构解耦,使得集合类本身保持简洁。

import java.util.Iterator;
import java.util.NoSuchElementException;
public class CustomList<T> implements Iterable<T> {
private Object[] elements;
private int size;
private static final int DEFAULT_CAPACITY = 10;
public CustomList() {
this.elements = new Object[DEFAULT_CAPACITY];
this.size = 0;
}
public void add(T item) {
if (size == elements.length) {
resize();
}
elements[size++] = item;
}
private void resize() {
elements = java.util.Arrays.copyOf(elements, elements.length * 2);
}
@Override
public Iterator<T> iterator() {
return new CustomIterator();
}
private class CustomIterator implements Iterator<T> {
private int currentIndex = 0;
@Override
public boolean hasNext() {
return currentIndex < size;
}
@Override
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
@SuppressWarnings("unchecked")
T item = (T) elements[currentIndex];
currentIndex++;
return item;
}
}
public static void main(String[] args) {
CustomList<String> list = new CustomList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
for (String fruit : list) {
System.out.println(fruit);
}
}
}
上述代码展示了一个简单的动态数组实现。当调用 iterator() 时,它创建一个新的 CustomIterator 实例,该实例初始索引为 0。在增强型 for 循环中,编译器会将其转换为对 iterator() 的调用,随后反复调用 hasNext() 和 next()。如果尝试在最后一个元素后继续调用 next(),则会抛出 NoSuchElementException,这是标准行为。
立即学习“Java免费学习笔记(深入)”;
如何处理并发修改异常
在使用迭代器遍历集合时,如果在遍历过程中直接修改了集合的结构(如添加或删除元素),通常会触发 ConcurrentModificationException。为了防止这种情况,可以在迭代器中引入一个 modCount 变量,记录集合被修改的次数。每次集合发生结构性修改时,递增这个计数器。在迭代器的 next() 和 hasNext() 方法中,检查当前的 modCount 是否与初始化时的值一致。如果不一致,说明集合在遍历期间被修改过,此时应抛出异常。这种快速失败机制有助于尽早发现潜在的并发问题,避免不可预知的行为。

import java.util.Iterator;
import java.util.NoSuchElementException;
public class SafeCustomList<T> implements Iterable<T> {
private Object[] elements;
private int size;
private int modCount = 0;
private static final int DEFAULT_CAPACITY = 10;
public SafeCustomList() {
this.elements = new Object[DEFAULT_CAPACITY];
this.size = 0;
}
public void add(T item) {
if (size == elements.length) {
resize();
}
elements[size++] = item;
modCount++; // 结构性修改,增加计数
}
private void resize() {
elements = java.util.Arrays.copyOf(elements, elements.length * 2);
}
@Override
public Iterator<T> iterator() {
return new SafeCustomIterator();
}
private class SafeCustomIterator implements Iterator<T> {
private int currentIndex = 0;
private int expectedModCount = modCount; // 记录初始修改次数
@Override
public boolean hasNext() {
checkForComodification();
return currentIndex < size;
}
@Override
public T next() {
checkForComodification();
if (!hasNext()) {
throw new NoSuchElementException();
}
@SuppressWarnings("unchecked")
T item = (T) elements[currentIndex];
currentIndex++;
return item;
}
private void checkForComodification() {
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
}
public static void main(String[] args) {
SafeCustomList<String> list = new SafeCustomList<>();
list.add("Apple");
list.add("Banana");
try {
for (String fruit : list) {
System.out.println(fruit);
list.add("Orange"); // 遍历时添加元素,触发异常
}
} catch (ConcurrentModificationException e) {
System.out.println("检测到并发修改");
}
}
}
在这个改进版本中,SafeCustomList 增加了 modCount 字段。每次调用 add() 时,modCount 都会自增。迭代器在创建时保存当前的 modCount 到 expectedModCount。在每次调用 next() 或 hasNext() 时,都会调用 checkForComodification() 方法来比较这两个值。如果它们不相等,说明集合在遍历过程中被修改了,从而抛出 ConcurrentModificationException。这确保了遍历过程的完整性,防止因并发修改导致的数据不一致。
为什么 next() 需要抛出 NoSuchElementException
在实现 Iterator 接口时,next() 方法必须在没有更多元素时抛出 NoSuchElementException。这是 Java 集合框架的标准约定,旨在明确区分“没有更多元素”和“其他错误”。如果 next() 在没有元素时返回 null,调用者可能无法区分是集合中确实存在 null 值,还是已经遍历完毕。抛出异常可以强制调用者在调用 next() 之前先检查 hasNext(),或者使用 try-catch 块来处理异常情况。这种设计提高了代码的健壮性,避免了因隐式 null 返回而导致的潜在空指针异常或其他逻辑错误。


















