Question

我想用布尔标志在数组上写Iterator。我的类实现了Iterable接口。类的主要思想是实现Integer子阵列。例如，我想将数字放在10到20之间的数组中。如果number在数组中，则数组中将存在true inits。数字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方法中我可以看到一些问题：

currIndex仅在elementFlags[currentIndex]为false时才会提前，这意味着您的迭代器将停留在数组包含true的第一个索引处。
我想你想循环遍历索引，直到找到数组包含true的下一个索引，并返回该索引。
您应该初始化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

你有没有特别的理由重新发明轮子？

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

或者在这些索引处访问数组的元素：

{{1}}

在Java中迭代布尔数组

2 个答案: