在Java中迭代布尔数组

Question

我想用布尔标志在数组上编写迭代器。 我的类实现了接口Iterable。 类的主要思想是实现整数子数组。 例如，我想将 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;
    }
}

这段代码中使用的变量是： lowerBound：数组中可能的较低元素 size：数组大小（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. 您应该初始化迭代器，使初始的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));