在Java中對布爾數組進行迭代

Question

我想用布爾標誌在數組上編寫Iterator。 我的類實現了接口Iterable。 類的主要思想是實現Integer子數組。例如，我想將10和20之間的數字放在數組中。 如果數組在數組中，那麼數組中就會有真正的數字。 編號10具有陣列索引0等

我寫這個亞類：

private class RangeIter implements Iterator<Integer> { 

    private int currentIndex = 0; 

    @Override 
    public boolean hasNext() { 
     return currentIndex < size; 


    } 

    @Override 
    public Integer next() { 
     if (!hasNext()) { 
      throw new NoSuchElementException("No elements more!"); 
     } 
     Integer element = currentIndex; 
     if (!elementFlags[currentIndex]) { 
      currentIndex++; 
     } 
     return element + lowerBound; 
    } 
} 

在這段代碼中使用的變量是： 下界：下可能元件陣列 尺寸：陣列的大小（upperBound - lowerBound +1）

我的問題是： 爲什麼這個迭代器不起作用？

這裏是我的代碼休息：

public class FixedRangeIntegerSet implements Iterable<Integer> { 

    private boolean[] elementFlags; 
    private int size; 
    private int lowerBound; 
    private int upperBound; 

    public FixedRangeIntegerSet(int lowerBound, int upperBound) { 
     this.lowerBound = lowerBound; 
     this.upperBound = upperBound; 
     int size = upperBound - lowerBound + 1; 
     elementFlags = new boolean[size + 1]; 
     this.size = size; 
    } 

    public FixedRangeIntegerSet(int lowerBound, int upperBound, Iterable<Integer> elements) { 
     int sizeCopy = size; 
     for (Integer element : elements) { 
      if (sizeCopy > 0) { 
       add(element); 
       sizeCopy--; 
      } 
     } 
    } 

    public FixedRangeIntegerSet(int lowerBound, int upperBound, Integer... elements) { 
     for (int i = 0; i < elements.length; i++) { 
      add(elements[i]); 
     } 
    } 

    public boolean add(Integer element) { 
     if (elementFlags[element - lowerBound] == true) { 
      return false; 
     } 
     elementFlags[element - lowerBound] = true; 
     return true; 
    } 

    public boolean containsElement(Integer element) { 
     if (element < lowerBound || element > upperBound) { 
      return false; 
     } 
     if (elementFlags[element - lowerBound] == true) { 
      return true; 
     } else 
      return false; 
    } 

    public int getSize() { 
     int size = 0; 
     for (Boolean i : elementFlags) { 
      if (i == true) { 
       size++; 
      } 
     } 
     return size; 
    } 

    public int getLowerBound() { 
     return lowerBound; 
    } 

    public int getUpperBound() { 
     return upperBound; 
    } 

    public boolean remove(Integer element) { 
     if (elementFlags[element - lowerBound] == false) { 
      return false; 
     } else { 
      elementFlags[element - lowerBound] = false; 
      return true; 
     } 
    } 

Answer 1

你是不是給我們所有的相關代碼，但只是從你的hasNext和next方法，我可以看到一些問題：

1. currIndex只有在elementFlags[currentIndex]爲false時纔會進階，這意味着您的迭代器會卡在數組包含true的第一個索引處。

2. 我想你想遍歷索引，直到找到數組包含true的下一個索引並返回該索引。

3. 您應該初始化Iterator，以便currentIndex的初始值爲elementFlags[currentIndex]爲真。

一個建議的落實：

private class RangeIter implements Iterator<Integer> { 

    private int currentIndex = 0; 

    public RangeIter() 
    { 
     currentIndex = 0; 
     while (currentIndex < size && !elementFlags[currentIndex]) 
      currentIndex++; 
    } 

    @Override 
    public boolean hasNext() { 
     return currentIndex < size; 
    } 

    @Override 
    public Integer next() { 
     if (!hasNext()) { 
      throw new NoSuchElementException("No elements more!"); 
     } 
     Integer element = currentIndex; 
     while (currentIndex < size && !elementFlags[currentIndex]) { 
      currentIndex++; 
     } 
     return element + lowerBound; 
    } 

} 

Answer 2

有你重新發明輪子一個特別的原因？

IntStream.range(lowerBound, upperBound).forEach(i -> doSomethingWith(i)); 

或者在這些索引來訪問數組中的元素：

Object[] someArray; 
IntStream.range(lowerBound, upperBound) 
    .map(i -> someArray[i]) 
    .forEach(obj -> doSomethingWith(obj));