Question

I have the following scenario: I have an existing iterator Iterator<String> it and I iterate over its head (say first k elements, which are flagged elements, i.e. they start with ‘*’ ). The only way to know that the flagged elements are over, is by noticing that the (k+1)th element is not flagged.

The problem is that if I do that, the iterator it will not provide me the first value anymore on the next call to next().

I want to pass this iterator to a method as it’s only argument and I would like to avoid changing its signarture and it implementation. I know I could do this:

   public void methodAcceptingIterator(Iterator<String> it) //current signature

   //change it to 

  public void methodAcceptingIterator(String firstElement, Iterator<String> it)

But this looks like a workarround/hack decreasing the elegance and generality of the code, so I don’t want to this.

Any ideas how I could solve this problem ?

Answer 1

The solution is to create your own Iterator implementation which stores the firstElement and uses the existing iterator as an underlying Iterator to delegate the requests for the rest of the elements to.

Something like:

  public class IteratorMissingFirst<E> implements Iterator<E>{

private Iterator<E> underlyingIterator;
private E firstElement;
private boolean firstElOffered;

public IteratorMissingFirst(E firstElement, Iterator<E> it){
    //initialize all the instance vars
}

public boolean hasNext(){
    if(!firstElOffered && firstElement != null){
            return true;
    }
    else{
        return underlyingIterator.hasNext();
    }
}

public E next(){
    if(!firstElOffered){
        firstElOffered = true;
        return firstElement;
    }
    else return underlyingIterator.next();
}

public void remove(){

}
}