Question

我正在使用Netbeans在Java中编写一个简短的算法。

我遇到的问题是代码忽略了while循环中的return语句。我也尝试了一个break语句，它也忽略了这一点。

但是，关于整个事情的奇怪之处在于，当我使用断点运行程序时，它会在应该（当它看到某个值时）停止。如果我在没有断点的情况下运行它，它就会超过这一点。

以下是一些代码：

    while (!openList.isEmpty()) {
        // 1. Remove the best node from OPEN, call it current
        int bestValue = Integer.MAX_VALUE;
            for (BestFirstNode inOpen : openList) {
                if ((inOpen.x == current.x) && (inOpen.y == current.y)) {
                    //skip this node
                }
                // 2.If one of the values in openList is the goal state, return the goal value
                if (inOpen.value < bestValue) {
                    if (inOpen.value == goal) {
                       System.out.println("GOAL!");
                       openList.clear();
                       return goal;
                    }
                    //else sent thevalue if the new current nodes
                    bestValue = inOpen.value;
                    current = inOpen;

                    //set the new x and y values that will be used to check
                    //for successors
                    x = inOpen.x;
                    y = inOpen.y;
                }
            }

        //print the current node and its coordinates
        System.out.println("Current: " + current.value);
        System.out.println("x: " + current.x + " y: " + current.y + "\n-------------");

        //remove current from the openList so it can't be used again
        openList.remove(current);

        //3. Create current's successors.
        Set<BestFirstNode> successors = new HashSet();
        int min = 0;
        int max = 2;

        //get the top successor
        if ((x <= max) && (x >= min) && (y - 1 <= max) && (y - 1 >= min)) {
            successors.add(grid[x][y - 1]);
        }

        //get the bottom successor
        if (x <= max && x >= min && y + 1 <= max && y + 1 >= min) {
            successors.add(grid[x][y + 1]);
        }

        //get the left successor
        if (x - 1 <= max && x - 1 >= min && y <= max && y >= min) {
            successors.add(grid[x - 1][y]);
        }

        //get the right successor
        if (x + 1 <= max && x + 1 >= min && y <= max && y >= min) {
            successors.add(grid[x + 1][y]);
        }

        //remove the parent node from the successors list
        Set<BestFirstNode> successorsFinal = new HashSet<>();
        for (BestFirstNode successor : successors) {
            if (successor != current.parent) {
                successorsFinal.add(successor);
            }
        }

        //4. Evaluate each successor, add it to OPEN, and record its parent.
        for (BestFirstNode successor : successorsFinal) {
            openList.add(successor);
            successor.parent = current;
        }
    }

我读了一些关于类似问题的其他帖子。阅读一篇文章（here）让我尝试运行没有断点的调试器。如果没有它们，我会遇到同样的问题，但我并不完全理解答案。我也尝试清除列表，因此while条件无效，但它仍然继续。

所以，我想我的问题是双重的：
代码如何完全忽略break或return语句？你如何使用断点获得一个结果而没有断点却得到另一个结果？

编辑：为了清晰起见，我添加了完整的while循环

Answer 1

Card是否被其他线程写入/更改？也许它不是一个线程安全列表被另一个线程修改而不是你的while循环线程？或者哪个线程将目标添加到列表中？

Answer 2

您的代码在return语句之后运行是不可能的。在返回语句后，解释器退出方法，我可以向你证明这一点。

以下测试在return语句之前和之后添加System.out.printl，无论是否运行带有断点的代码，都会得到与return语句相同的结果。 编辑： 我不确定此测试是否可行。如果无法访问的代码被标记为警告或错误，我无法重新构建。

中断语句也是如此，在中断语句后退出循环。但是当你在彼此内部使用多个循环时，识别你正在退出的循环会很困惑。

如果你有手表，程序可以在调试模式内改变它的行为。如果您观看的方法发生了变化，那么您将拥有不同的行为。

示例：

int getX(){
    y++;
    return x;
}

如果你在每个断点之后对getX（）进行监视，调试器将调用getX（）并且y将增加1.并且你的程序将具有与运行模式不同的行为。

结论：

程序永远不会忽略return或break语句，请证明我错了。
断点刷新手表，手表调用他们正在观看的方法。如果这些方法改变了价值，那么你将会有不同的行为。

返回语句和中断不在“While循环”中工作

2 个答案: