Question

我有一个对象列表，想要向前和向后迭代，直到找到一个有效的＆＃34;有效的元素。

MyClass {
    private boolean valid;
    public boolean isValid() { return valid; }
}

List<MyClass> classes; //assume sorted list

现在我想从位置idx开始，并向前和向后迭代以找到最有效的元素。到目前为止，我已经得到了正向算法。但我觉得代码可以优化：

//应该从位置X开始

int idx = 10;

//find the closest element that is valid
for (ListIterator<MyClass> itr = classes.listIterator(idx); itr.hasNext();) {
    if (itr.hasNext()) {
        MyClass my = itr.next();
        while (!my.isValid()) {
            if (itr.hasNext()) {
                my = itr.next();
            } else {
                break;
            }
        }
    }
    Sysout("the closest valid element is: " + my);
}

迭代器算法可以更好地编写吗？

Answer 1

同时使用两个迭代器。在idx处启动它们，并在循环的每次迭代中推进它们，直到达到限制：

ListIterator<MyClass> fwd = classes.listIterator(idx);
ListIterator<MyClass> bck = classes.listIterator(idx);
MyClass found = null;
while (fwd.hasNext() || bck.hasPrevious()) {
    if (fwd.hasNext()) {
        MyClass my = fwd.next();
        if (my.isValid()) {
            found = my;
            break;
        }
    }
    if (bck.hasPrevious()) {
        MyClass my = bck.previous();
        if (my.isValid()) {
            found = my;
            break;
        }
    }
}

如果循环结束时found为null，则找不到有效的项目。否则，found包含距idx最近的项目。如果两个有效项目与idx的距离相同，则返回前方的项目。

Answer 2

      package iteratorPract;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class MyIterClass {
    private boolean valid;

    public boolean isValid() {
        return this.valid;
    }

    public void setValid(boolean valid) {
        this.valid = valid;
    }

    public static void main(String[] args) {
        MyIterClass m1 = new MyIterClass();
        m1.setValid(true);
        MyIterClass m2 = new MyIterClass();
        List<MyIterClass> classes = new ArrayList<MyIterClass>();
        classes.add(m1);
        classes.add(m2);

        // from last
        ListIterator<MyIterClass> l1 = classes.listIterator(classes.size());

        while (l1.hasPrevious()) {
            if (l1.previous().isValid())
                System.out.println("it is valid");
            else
                System.out.println("not valid");
        }
        // from start
        ListIterator<MyIterClass> l2 = classes.listIterator();

        while (l1.hasNext()) {
            if (l1.next().isValid())
                System.out.println("it is valid");
            else
                System.out.println("not valid");
        }

    }

}

Answer 3

您可以使用Iterator#hasPrevious()和Iterator#previous()进行反向迭代使用ListIterator进行前向迭代的Iterator#hasNext()和Iterator#next()。

如何在两个方向上迭代列表？

3 个答案: