Question

我试图解决这个问题，但不能。

我需要实现一个实现迭代器的类，并将迭代器作为构造函数参数，

1）需要返回每个第二个hasnext

2）需要返回每个第二个下一个元素

基本上我正在尝试使用从构造函数接收的给定迭代器，但是当我在hasnext上使用下一个元素时，我实际上是通过一个元素增加迭代器。当我独立访问hasNext或next元素并且没有通过所有测试用例时，问题就出现了。关于此

的任何解决方案或想法

模板和我期望的实现如下所示：

public class AlternateIterator<T> implements Iterator<T>
public AlternateIterator(Iterator<T> target)

public boolean hasNext() {
        boolean returnvalue = false;
                if(iterator.hasNext()) {
                    iterator.next();
                    returnvalue = iterator.hasNext();
                }
                return returnvalue;

    }

    @Override
    public T next() {
        T object = null;
        if(iterator.hasNext()) {
        object  = iterator.next();
        return object;
        }
        else
            return null;

- 通过此链接但它创建了一个新的实现，而我只想使用给定的模板：

Can we write our own iterator in Java?

Answer 1

跟踪您是否从源迭代器中跳过了元素，如下所示：

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;

final class AlternateIterator<T>
  implements Iterator<T>
{

  static <T> Iterable<T> alternate(Iterable<T> original)
  {
    return () -> new AlternateIterator<>(original.iterator());
  }

  private final Iterator<T> source;

  private boolean skipped;

  AlternateIterator(Iterator<T> source)
  {
    this.source = Objects.requireNonNull(source);
  }

  @Override
  public boolean hasNext()
  {
    if (!skipped) {
      if (source.hasNext())
        source.next();
      skipped = true;
    }
    return source.hasNext();
  }

  @Override
  public T next()
  {
    if (hasNext()) {
      skipped = false;
      return source.next();
    }
    throw new NoSuchElementException();
  }

  @Override
  public void remove()
  {
    source.remove();
  }

}

Answer 2

您的问题是hasNext()更改了修饰的Iterator的状态。您需要一个像skipped这样的成员变量来跟踪状态，以便hasNext()不会翻倍并跳过两个，而next()的实现应该使用this.hasNext()，而不是iterator.hasNext() {1}}。

编辑：它看起来像这样：

public class AlternateIterator<T> implements Iterator<T> {
    public AlternateIterator(Iterator<T> target) { ... }

    private volatile boolean skipped = false;

    public boolean hasNext() {
        if (!skipped) {
            skipped = true;
            if (iterator.hasNext()) {
                iterator.next();
            }
        }
        return iterator.hasNext();
    }

    @Override
    public T next() {
        hasNext();
        skipped = false;
        return iterator.next();
    }
}

Answer 3

你需要有一个布尔成员存储自上次调用next以来是否已调用hasNext。通过这种方式，您可以知道是否需要在两种方法中再调用一次或更多。

如何迭代java

3 个答案: