Java 对于每个，但多个迭代器类型？

Question

我有一个 Polygon 类，我希望在其上实现两个迭代器：一个迭代器仅运行一次所有元素（按交替顺序的顶点和边），另一个迭代器无限地（循环）运行它们。

从 for-each 用法的角度来看，我的猜测是，通过实现 Iterable.iterator()<，我只能将上述之一作为可与 for-each 一起使用的默认迭代器。 /代码>。这是正确的吗？或者有没有一种方法可以将 for-each 与两者一起使用？

Answer 1

只需添加两个返回两个不同迭代器的方法，每个迭代器对应一种情况：

public Iterable<String> eachOnce() {
    List<String> allResults = new ArrayList<String>();
    // fill list
    return allResults;
}

public Iterable<String> eachCyclic() {
    return new Iterable<String>() {

        public Iterator<String> iterator() {
            return new Iterator<String>() {

                public boolean hasNext() {
                    return true;
                }

                public String next() {
                    // TODO implement
                    return null;
                }

                public void remove() {
                    // do nothing
                }
            };

        }
    };
}

这只是一个字符串列表的示例，只需适应即可。

而不是

for (Polygon p : polygons) { }

仅仅使用

for (Polygon p : polygons.eachOnce()) { }

或循环版本

Answer 2

我认为比已经提出的答案更好的答案是一种将任何 Iterable 转换为循环的方法。

public class IterableUtils {
  public static class CyclicIterator<T> implements Iterator<T> {
    private final Iterable<T> inner;
    private Iterator<T> currentIter;
    public CyclicIterator(Iterable<T> inner) {
      this.inner = inner;
    }
    public boolean hasNext() {
      if (currentIter == null || !currentIter.hasNext()) {
        currentIter = inner.iterator();
      }
      return currentIter.hasNext();
    }
    public T next() {
      if (currentIter == null || !currentIter.hasNext()) {
        currentIter = inner.iterator();
      }
      return currentIter.next();
    }
    public void remove() {
      currentIter.remove();
    }
  }
  public static <T> Iterable<T> cycle(final Iterable<T> i) {
    return new Iterable<T>() {
      public Iterator<T> iterator() { return new CyclicIterator<T>(i); }
    };
  }
}

然后，您可以在 Polygon 类中实现单个迭代器方法，并使用

for (Element e: polygon) {
  ...
}

迭代一次和

for (Element e: Cycle(polygon)) {
...
}

无限迭代。作为奖励，循环修饰符可以应用于任何可迭代对象。