如何实现跳转迭代器

Question

Implement next() and hasNext() of a jump iterator, the constructor was passed with another iterator. The next() function will return iterator.next().next()

I have implemented below code, it doesn't look elegant at all. And for list {1, 9, 8, 7, 8, 2, 5}, it will only output 9, 7, 2. Any clue to do it in a better way?

Basically this jump iterator is trying to iterator each element with one distance, for example, for 1,2,3,4,5, it will return 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

It seems to me that your problem is in the function 'hasNext'

Why do you override it? What behaviour do you want to obtain?

When it.hasNext() returns true you consume a value you shouldn't be consuming, due to the use of it.next() right there.

Answer 2

Those method implementations are currently assuming that the program always interlaces calls to hasNext and next , which may bring some issues in the long run.

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

Here is a way around the problem. In short, I'm keeping track of whether the next value was already checked, which in that case I have already skipped one value.

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();
    }
}

Other than that, the jump iterator works if the intended goal is to "skip once and take the next" each time an element is retrieved. Under this logic, using the iterator on the sequence [1,2,3,4] would give you [2,4] . If you want to have [1,3] instead (as in, not skipping the first value), just tweak the implementation as shown above.

Answer 3

I'd make it something like

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;
  }
}

This will not skip the first element. If you want to do that, then you need the lazy skipping policy described by E_net4. I'd just factor it out:

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() {
  }
}