java - 如何迭代点 (x, y) 上的序数方向？

Question

我在下面有一个名为 findNeighboringChains(i, j) 的函数。您传入一个点 (x, y)，它会返回相邻点 (x + 1, y)、(x - 1, y)、(x, y + 1) 和 (x, y - 1)。如果 (x, y) 处不存在链，则 findChainId(x, y) = -1，否则将返回 ID >= 0。每个 (x, y) 处只能存在一个链。为了了解更多背景信息，这是我用来在围棋游戏中查找与单元格相邻的链的函数。

我觉得到目前为止我所拥有的有点冗长，但我不知道如何让它变得更好。如果我可以通过循环迭代这些点 (x + 1, y) .​​.. (x, y - 1) ，这似乎是理想的选择。有什么建议吗？

public ArrayList<Integer> findNeighboringChains(int i, int j) {
    ArrayList<Integer> neighboringChains = new ArrayList<>();

    int tmp = findChainId(i - 1, j);
    if (tmp != -1) {
        neighboringChains.add(tmp);
    }

    tmp = findChainId(i + 1, j);
    if (tmp != -1) {
        neighboringChains.add(tmp);
    }

    tmp = findChainId(i, j - 1);
    if (tmp != -1) {
        neighboringChains.add(tmp);
    }

    tmp = findChainId(i, j + 1);
    if (tmp != -1) {
        neighboringChains.add(tmp);
    }

    return neighboringChains;
}

Answer 1

一种方法是利用 Java 中内置的 Point 对象，并迭代点列表 - 每次调用同一段代码。在我的解决方案/重构中，我创建了一个名为“getNeighboringPoints(Point p)”的新方法，它检索四个相邻点。然后，在函数 findNeighboringChains 中，您可以使用 for-each 循环对该点列表进行迭代。

您可以对这种模式进行很多变体，但您认为可以减少冗余的想法绝对是正确的。尝试遵循 DRY 原则总是一个好主意。

public ArrayList<Integer> findNeighboringChains(int i, int j) {
    ArrayList<Integer> neighboringChains = new ArrayList<>();

    Point p = new Point(i, j);
    List<Point> neighboringPoints = getNeighboringPoints(p);

    for (Point point : neighboringPoints) {
        int tmp = findChainId(point.x, point.y);
        if (tmp != -1) {
            neighboringChains.add(tmp);
        }
    }

    return neighboringChains;
}

/**
 * 
 * @param p
 *            The input point.
 * @return a list of points neighboring point p
 */
private List<Point> getNeighboringPoints(Point p) {
    ArrayList<Point> neighboringPoints = new ArrayList<Point>();
    neighboringPoints.add(new Point(p.x - 1, p.y));
    neighboringPoints.add(new Point(p.x + 1, p.y));
    neighboringPoints.add(new Point(p.x, p.y + 1));
    neighboringPoints.add(new Point(p.x, p.y - 1));
    return neighboringPoints;
}

上述方法的好处之一是，现在您可以稍后发现可能需要对所有相邻点进行另一次操作，并且可以重用 getNeighboringPoints() 方法。

编辑:

减少冗余的另一种方法是使用 extract method技术。

public ArrayList<Integer> findNeighboringChains(int i, int j) {
    ArrayList<Integer> neighboringChains = new ArrayList<>();

    int tmp = findChainId(i - 1, j);
    checkChain(neighboringChains, tmp);

    tmp = findChainId(i + 1, j);
    checkChain(neighboringChains, tmp);

    tmp = findChainId(i, j - 1);
    checkChain(neighboringChains, tmp);

    tmp = findChainId(i, j + 1);
    checkChain(neighboringChains, tmp);

    return neighboringChains;
}

private void checkChain(ArrayList<Integer> neighboringChains, int tmp) {
    if (tmp != -1) {
        neighboringChains.add(tmp);
    }
}

这可能会更好，因为它不会强制在已经不使用点的项目上使用点类。 (当有一种方法使用点而其他所有方法都需要输入两个整数时，这可能会很烦人)。