关于快速生成Java Iterator视图的API实现问询

看起来你想要一个流畅的链式API，能快速给集合创建各种定制化的迭代视图——比如从指定位置开始反向遍历列表这种，而且还希望实现简单、性能不打折扣对吧？我太懂这种需求了：Java标准库里虽然有Map的keySet/entrySet这类视图支持，但针对List这类结构的灵活迭代，确实缺个顺手的工具。

一种轻量高效的实现思路 #

我们可以用装饰器模式封装原List，通过链式方法配置迭代规则，最后动态生成对应的迭代器——全程不需要复制原数据，性能和直接遍历原列表几乎无差。

先给你写个核心实现，刚好能支持你想要的iter(myList).from(24).backwards()调用风格：

import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

public class IterableWrapper<A> implements Iterable<A> {
    private final List<A> source;
    private int startIndex = 0;
    private boolean reverse = false;

    // 私有构造，强制通过静态工厂方法创建
    private IterableWrapper(List<A> source) {
        this.source = source;
    }

    // 入口方法，对应你要的iter(myList)
    public static <A> IterableWrapper<A> iter(List<A> source) {
        return new IterableWrapper<>(source);
    }

    // 设置起始遍历位置
    public IterableWrapper<A> from(int index) {
        if (index < 0 || index >= source.size()) {
            throw new IllegalArgumentException("起始索引超出列表范围");
        }
        this.startIndex = index;
        return this;
    }

    // 设置反向遍历
    public IterableWrapper<A> backwards() {
        this.reverse = true;
        return this;
    }

    @Override
    public Iterator<A> iterator() {
        if (reverse) {
            // 生成反向迭代器：从startIndex往前遍历
            return new Iterator<>() {
                private int current = startIndex;

                @Override
                public boolean hasNext() {
                    return current >= 0;
                }

                @Override
                public A next() {
                    if (!hasNext()) {
                        throw new NoSuchElementException("没有更多元素");
                    }
                    return source.get(current--);
                }
            };
        } else {
            // 生成正向迭代器：从startIndex往后遍历
            return new Iterator<>() {
                private int current = startIndex;

                @Override
                public boolean hasNext() {
                    return current < source.size();
                }

                @Override
                public A next() {
                    if (!hasNext()) {
                        throw new NoSuchElementException("没有更多元素");
                    }
                    return source.get(current++);
                }
            };
        }
    }
}

为什么这个方案适合你？ #

• 性能友好：全程只是包装原列表，没有任何数据复制操作，迭代速度和直接用List的原生迭代器几乎一致；
• 链式调用流畅：完全符合你想要的iter(myList).from(24).backwards()写法，可读性拉满；
• 扩展性强：如果之后需要更多视图（比如遍历到指定结束位置、过滤元素），只需要在IterableWrapper里加对应的配置方法和迭代器逻辑就行，比如加个to(int endIndex)方法限制结束位置，或者filter(Predicate<A> filter)做元素过滤。

额外补充：基于Stream的简化方案 #

如果你用Java 8及以上，也可以结合Stream API快速实现类似效果，虽然反向遍历会有一次临时集合复制（性能略逊于自定义迭代器），但代码更简洁：

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class IterUtils {
    public static <A> Stream<A> from(List<A> source, int start) {
        return source.stream().skip(start);
    }

    public static <A> Stream<A> backwards(Stream<A> stream) {
        List<A> temp = stream.collect(Collectors.toList());
        Collections.reverse(temp);
        return temp.stream();
    }
}

// 使用示例：
for (A it : IterUtils.backwards(IterUtils.from(myList, 24)).collect(Collectors.toList())) {
    // 你的业务逻辑
}

不过如果追求极致性能，还是自定义迭代器的方案更靠谱~

备注：内容来源于stack exchange，提问作者Taren