如何实现跳转迭代器

Question

实现跳转迭代器的next()和hasNext()，构造函数与另一个迭代器一起传递。 next() 函数将返回 iterator.next().next()

我已经实现了下面的代码，它看起来一点也不优雅。 而对于列表 {1, 9, 8, 7, 8, 2, 5}，它只会输出 9, 7, 2。 有什么更好的方法吗？

基本上这个跳转迭代器是试图迭代每个元素一个距离，例如对于1,2,3,4,5，它会返回1,3,5

public class JumpIterator implements Iterator<Integer> {
    private Iterator<Integer> it;

    public JumpIterator(List<Integer> list){
        it = list.iterator();
    }

    @Override
    public boolean hasNext() {
        if(!it.hasNext()){
            return false;
        }else{
            it.next();
            return it.hasNext();
        }
    }

    @Override
    public Integer next() {
        return it.next();
    }
}

Answer 1

在我看来，您的问题出在函数“hasNext”中

为什么要覆盖它？你想获得什么行为？

当 it.hasNext() 返回 true 时，你会消耗一个你不应该消耗的值，因为它在那里使用了 it.next()。

Answer 2

这些方法实现目前假设程序总是交替调用hasNext 和next，从长远来看这可能会带来一些问题。

JumpIterator jit = ...;
jit.hasNext();
jit.haxNext(); // skipped a relevant value
jit.next();
jit.next(); // obtained two adjacent values

这是解决问题的方法。简而言之，我正在跟踪是否已经检查了下一个值，在这种情况下，我已经跳过了一个值。

public class JumpIterator implements Iterator<Integer> {
    private Iterator<Integer> it;
    private boolean skipped;

    public JumpIterator(List<Integer> list){
        it = list.iterator();
        skipped = false; 
        // if you want to take the first value from the stream,
        // change skipped to true
    }

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

    @Override
    public Integer next() {
        if (!skipped) {
            it.next();
        }
        skipped = false;
        return it.next();
    }
}

除此之外，如果预期目标是每次检索元素时“跳过一次并获取下一个”，则跳转迭代器会起作用。在这种逻辑下，在序列[1,2,3,4] 上使用迭代器会得到[2,4]。如果您想改用[1,3]（如，不跳过第一个值），只需调整如上所示的实现。

Answer 3

我会把它做成这样的

public class JumpIterator implements Iterator<Integer> {
  private Iterator<Integer> it;

  public JumpIterator(List<Integer> list){
    this.it = list.iterator();
  }

  @Override
  public boolean hasNext() {
    //hasNext should be idempotent (should not modify the state)
    return it.hasNext();
  }

  @Override
  public Integer next() {
    //If the user didn't check hasNext()
    // NoSuchElementException might be thrown,
    // which is interface-compliant, so we just don't care
    Integer nNext = it.next();

    //Now we must skip the next value
    if (it.hasNext()) it.next();
    return nNext;
  }
}

这将不会跳过第一个元素。 如果你想这样做，那么你需要 E_net4 描述的惰性跳过策略。我只是把它排除在外：

public class JumpIterator implements Iterator<Integer> {
  private Iterator<Integer> it;
  private boolean bMustSkip;

  public JumpIterator(List<Integer> list){
    this.it = list.iterator();
    this.bMustSkip = true;
  }

  private Iterator<Integer> myIterator() {
    if (bMustSkip && it.hasNext()) {
      it.next(); //Skipped
    }
    bMustSkip = false;
    return it;
  }  

  @Override
  public boolean hasNext() {
    //hasNext should be idempotent (should not modify the state)
    return myIterator().hasNext();
  }

  @Override
  public Integer next() {
    //If the user didn't check hasNext()
    // NoSuchElementException might be thrown,
    // which is interface-compliant, so we just don't care
    Integer nNext = myIterator().next();
    bMustSkip = true;
    return nNext;
  }
}

Answer 4

public class JumpIterator implements Iterator<Integer> {
  Iterator<Integer> iterator;

  public JumpIterator(Iterator<Integer> iterator) {
    this.iterator = iterator;
  }

  @Override
  public boolean hasNext() {
    return iterator.hasNext();
  }

  @Override
  public Integer next() {
    int res = iterator.next();
    if (iterator.hasNext()) {
        iterator.next();
    }
    return res;
  }

  @Override
  public void remove() {
  }
}