java iterator 遍历装饰器模式通过实现 iterator 接口来包装现有的迭代器,从而在不修改原有集合类的前提下增加过滤、排序或转换等逻辑。具体做法是创建一个实现了 iterator<t></t> 的装饰器类,持有目标迭代器的引用,并在 next() 和 hasnext() 方法中嵌入自定义逻辑,例如跳过特定元素或进行类型转换。

如何封装现有迭代器以添加过滤逻辑
要封装现有迭代器并添加过滤逻辑,需要定义一个类实现 Iterator<e></e> 接口,并在构造函数中接收被包装的迭代器实例。在 hasNext() 方法中循环调用底层迭代器的 hasNext() 直到找到符合条件的元素或返回 false;在 next() 方法中直接返回当前找到的元素。这样可以在遍历过程中动态拦截数据流。

import java.util.Iterator;
import java.util.List;
public class FilteringIterator<E> implements Iterator<E> {
private final Iterator<E> delegate;
private E nextElement;
private boolean hasNextCalculated = false;
public FilteringIterator(Iterator<E> delegate) {
this.delegate = delegate;
calculateNext();
}
private void calculateNext() {
while (delegate.hasNext()) {
E candidate = delegate.next();
if (candidate != null && candidate.toString().length() > 3) {
this.nextElement = candidate;
this.hasNextCalculated = true;
return;
}
}
this.hasNextCalculated = false;
this.nextElement = null;
}
@Override
public boolean hasNext() {
if (!hasNextCalculated) {
calculateNext();
}
return hasNextCalculated;
}
@Override
public E next() {
if (!hasNext()) {
throw new java.util.NoSuchElementException();
}
E result = nextElement;
calculateNext(); // Prepare for next call
return result;
}
@Override
public void remove() {
throw new UnsupportedOperationException("Remove not supported in filtering wrapper");
}
}
// Usage Example:
// List<String> list = Arrays.asList("hi", "hello", "a", "world");
// Iterator<String> filtered = new FilteringIterator<>(list.iterator());
// while (filtered.hasNext()) {
// System.out.println(filtered.next());
// }上述代码创建了一个 FilteringIterator,它包装了任意 Iterator<e></e>。当调用 hasNext() 时,它会预加载下一个满足长度大于3条件的元素。如果底层迭代器耗尽或没有满足条件的元素,hasNext() 返回 false。这种设计确保了过滤逻辑在遍历时即时生效,且对调用者透明。
立即学习“Java免费学习笔记(深入)”;
在代码库出现结构漂移之前,扫描JS或TS代码库中的禁止导入、循环依赖、孤立模块和其他依赖规则违规情况。
如何实现链式装饰器以组合多个行为
实现链式装饰器可以让多个过滤或转换逻辑叠加。每个装饰器类都实现 Iterator<e></e> 并持有另一个 Iterator<e></e> 的引用。通过将前一个装饰器的输出作为后一个装饰器的输入,可以构建一条处理管道。关键在于每个装饰器只关注自己的逻辑,并将剩余工作委托给下一个迭代器。

import java.util.Iterator;
import java.util.Arrays;
import java.util.List;
// Base Decorator: Transformation
public class TransformingIterator<E, R> implements Iterator<R> {
private final Iterator<E> delegate;
private final java.util.function.Function<E, R> transformer;
private R nextElement;
private boolean hasNextCalculated = false;
public TransformingIterator(Iterator<E> delegate, java.util.function.Function<E, R> transformer) {
this.delegate = delegate;
this.transformer = transformer;
calculateNext();
}
private void calculateNext() {
while (delegate.hasNext()) {
E candidate = delegate.next();
this.nextElement = transformer.apply(candidate);
this.hasNextCalculated = true;
return;
}
this.hasNextCalculated = false;
this.nextElement = null;
}
@Override
public boolean hasNext() {
if (!hasNextCalculated) calculateNext();
return hasNextCalculated;
}
@Override
public R next() {
if (!hasNext()) throw new java.util.NoSuchElementException();
R result = nextElement;
calculateNext();
return result;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
// Chain Usage:
// List<String> data = Arrays.asList("apple", "banana", "cherry");
// Iterator<String> baseIter = data.iterator();
// // Filter length > 5, then convert to uppercase
// Iterator<String> filtered = new FilteringIterator<>(baseIter);
// Iterator<String> transformed = new TransformingIterator<>(filtered, String::toUpperCase);
// while (transformed.hasNext()) {
// System.out.println(transformed.next());
// }通过组合 FilteringIterator 和 TransformingIterator,可以实现复杂的数据处理流水线。例如,先过滤掉短字符串,再将剩余字符串转换为大写。每个装饰器独立运作,通过 Iterator 接口解耦,使得新增行为只需创建新的装饰器类并插入链中即可,符合开闭原则。
装饰器在空值或异常情况下如何处理
当底层迭代器抛出 ConcurrentModificationException 或遇到空值时,装饰器应保持一致性。在上述实现中,FilteringIterator 会跳过 null 值,而 TransformingIterator 若转换器接受 null 则传递 null,否则可能抛出 NPE。若底层迭代器因并发修改抛出异常,装饰器会将该异常透传,因为这是底层状态不一致的直接反映。建议在装饰器内部捕获并包装为 IllegalStateException 以提供更清晰的错误上下文,但标准做法通常是让异常传播,由调用者决定如何处理并发问题。

















