积极的迭代设计给定的IntegerIterator整数迭代

Question

（实现hasNext，接下来，删除）， 实现具有hasNext，旁边一个PositiveIterator，删除

任何人都可以给这个问题的一些想法？这不是一项功课！

例如：

int[] a = new int[]{1,-2,-3,4,5,-6,7,-8,9}; 
IntegerIterator it = new IntegerIterator(a); 
PositiveIterator iter = new PositiveIterator(it); 
Console.WriteLine(iter.HasNext()); //true 
Console.WriteLine(iter.HasNext()); //true 
Console.WriteLine(iter.HasNext()); //true 
Console.WriteLine(iter.Next()); //1 
Console.WriteLine(iter.Next()); //4 
Console.WriteLine(iter.Next()); //5 

Answer 1

PositiveIterator.Next应该不成问题。只需拨打Iterator.Next，直到值为正。 PositiveIterator.Remove只需要致电Iterator.Remove。 PositiveIterator.HasNext是代码会有点难看的原因，因为给定的方法只允许单向迭代。

class PositiveIterator: 
    int next = -1 //holds the next value to return 
    IntegerIterator iter //the integeriterator wrapped by this object 

    PositiveIterator(IntegerIterator it) 
     iter = it 

     //search for the first positive value for next 
     while iter.HasNext() AND ((next = iter.Next()) < 1) 
      NOOP 

    HasNext() 
     return next != -1 

    Next() 
     //the current value to return 
     int tmp = next 

     //search for the next positive value 
     while iter.HasNext() AND ((next = iter.Next()) < 1) 
      NOOP 

     if NOT iter.HasNext() 
      next = -1 //no next positive value available 

     return tmp 

    Remove() 
     if next == -1 
      return 

     iter.Remove() 

     //update the next value 
     next = Next() 

基本上PositiveInteger需要预测下一个将返回的值的值。

Answer 2

这是非常简单的 - 重写构造，HashNext()和Next()方法，这样你将永远有“手”下一个正值，而跳过所有负值。

伪代码：

class PositiveIterator: 
    private int next = -1; 
    private final Integer i; 
    PositiveIterator(Itertor i): 
      while (i.HashNext() && (next = i.Next()) <= 0) ; 
      //at this point next holds the next positive element, if such exists 
      this.i = i; 
    boolean HasNext(): 
     return (next > 0) 
    int Next(): 
     int tempVal = -1; 
     while (i.HashNext() && (tempVal = i.Next()) <= 0) ; 
     int res = next; 
     next = tempVal; 
     return next; 

注意，在任何时候，以任何方法 - next > 0当且仅当有留在数组中一些积极的元素，将举办下一个元素，你需要牛逼产生。