方法中的Java多维数组

Question

我知道多维数组，并且有点基础，但是我坚持将它们组合成布尔方法。 在这种情况下，我试图找出如何简化此方法的方法，该方法的作用是：

• 将一个具有位置（行：列）的数组与另一阵列（具有相同位置）进行比较。
• 如果两个数组中的所有位置都匹配，则应返回true。

下面的方法适用于我的代码，但是我想知道如何不单手“硬编码”数字的正确方法。 我是否需要使用嵌套的for循环来比较两个数组？

谢谢你的帮助〜

public static boolean gameIsWon(int[][] workingPuzzle, int[][] solvedPuzzle)
{
    if (workingPuzzle[0][0] == solvedPuzzle[0][0] &&
            workingPuzzle[0][1] == solvedPuzzle[0][1] &&
            workingPuzzle[0][2] == solvedPuzzle[0][2] &&
            workingPuzzle[0][3] == solvedPuzzle[0][3] &&
            workingPuzzle[0][4] == solvedPuzzle[0][4] &&
            workingPuzzle[0][5] == solvedPuzzle[0][5] &&
            workingPuzzle[0][6] == solvedPuzzle[0][6] &&
            workingPuzzle[0][7] == solvedPuzzle[0][7] &&
            workingPuzzle[0][8] == solvedPuzzle[0][8] &&
            workingPuzzle[1][0] == solvedPuzzle[1][0] &&
            workingPuzzle[1][1] == solvedPuzzle[1][1] &&
            workingPuzzle[1][2] == solvedPuzzle[1][2] &&
            workingPuzzle[1][3] == solvedPuzzle[1][3] &&
            workingPuzzle[1][4] == solvedPuzzle[1][4] &&
            workingPuzzle[1][5] == solvedPuzzle[1][5] &&
            workingPuzzle[1][6] == solvedPuzzle[1][6] &&
            workingPuzzle[1][7] == solvedPuzzle[1][7] &&
            workingPuzzle[1][8] == solvedPuzzle[1][8] &&
            workingPuzzle[2][0] == solvedPuzzle[2][0] &&
            workingPuzzle[2][1] == solvedPuzzle[2][1] &&
            workingPuzzle[2][2] == solvedPuzzle[2][2] &&
            workingPuzzle[2][3] == solvedPuzzle[2][3] &&
            workingPuzzle[2][4] == solvedPuzzle[2][4] &&
            workingPuzzle[2][5] == solvedPuzzle[2][5] &&
            workingPuzzle[2][6] == solvedPuzzle[2][6] &&
            workingPuzzle[2][7] == solvedPuzzle[2][7] &&
            workingPuzzle[2][8] == solvedPuzzle[2][8] &&
            workingPuzzle[3][0] == solvedPuzzle[3][0] &&
            workingPuzzle[3][1] == solvedPuzzle[3][1] &&
            workingPuzzle[3][2] == solvedPuzzle[3][2] &&
            workingPuzzle[3][3] == solvedPuzzle[3][3] &&
            workingPuzzle[3][4] == solvedPuzzle[3][4] &&
            workingPuzzle[3][5] == solvedPuzzle[3][5] &&
            workingPuzzle[3][6] == solvedPuzzle[3][6] &&
            workingPuzzle[3][7] == solvedPuzzle[3][7] &&
            workingPuzzle[3][8] == solvedPuzzle[3][8] &&
            workingPuzzle[4][0] == solvedPuzzle[4][0] &&
            workingPuzzle[4][1] == solvedPuzzle[4][1] &&
            workingPuzzle[4][2] == solvedPuzzle[4][2] &&
            workingPuzzle[4][3] == solvedPuzzle[4][3] &&
            workingPuzzle[4][4] == solvedPuzzle[4][4] &&
            workingPuzzle[4][5] == solvedPuzzle[4][5] &&
            workingPuzzle[4][6] == solvedPuzzle[4][6] &&
            workingPuzzle[4][7] == solvedPuzzle[4][7] &&
            workingPuzzle[4][8] == solvedPuzzle[4][8] &&
            workingPuzzle[5][0] == solvedPuzzle[5][0] &&
            workingPuzzle[5][1] == solvedPuzzle[5][1] &&
            workingPuzzle[5][2] == solvedPuzzle[5][2] &&
            workingPuzzle[5][3] == solvedPuzzle[5][3] &&
            workingPuzzle[5][4] == solvedPuzzle[5][4] &&
            workingPuzzle[5][5] == solvedPuzzle[5][5] &&
            workingPuzzle[5][6] == solvedPuzzle[5][6] &&
            workingPuzzle[5][7] == solvedPuzzle[5][7] &&
            workingPuzzle[5][8] == solvedPuzzle[5][8] &&
            workingPuzzle[6][0] == solvedPuzzle[6][0] &&
            workingPuzzle[6][1] == solvedPuzzle[6][1] &&
            workingPuzzle[6][2] == solvedPuzzle[6][2] &&
            workingPuzzle[6][3] == solvedPuzzle[6][3] &&
            workingPuzzle[6][4] == solvedPuzzle[6][4] &&
            workingPuzzle[6][5] == solvedPuzzle[6][5] &&
            workingPuzzle[6][6] == solvedPuzzle[6][6] &&
            workingPuzzle[6][7] == solvedPuzzle[6][7] &&
            workingPuzzle[6][8] == solvedPuzzle[6][8] &&
            workingPuzzle[7][0] == solvedPuzzle[7][0] &&
            workingPuzzle[7][1] == solvedPuzzle[7][1] &&
            workingPuzzle[7][2] == solvedPuzzle[7][2] &&
            workingPuzzle[7][3] == solvedPuzzle[7][3] &&
            workingPuzzle[7][4] == solvedPuzzle[7][4] &&
            workingPuzzle[7][5] == solvedPuzzle[7][5] &&
            workingPuzzle[7][6] == solvedPuzzle[7][6] &&
            workingPuzzle[7][7] == solvedPuzzle[7][7] &&
            workingPuzzle[7][8] == solvedPuzzle[7][8] &&
            workingPuzzle[8][0] == solvedPuzzle[8][0] &&
            workingPuzzle[8][1] == solvedPuzzle[8][1] &&
            workingPuzzle[8][2] == solvedPuzzle[8][2] &&
            workingPuzzle[8][3] == solvedPuzzle[8][3] &&
            workingPuzzle[8][4] == solvedPuzzle[8][4] &&
            workingPuzzle[8][5] == solvedPuzzle[8][5] &&
            workingPuzzle[8][6] == solvedPuzzle[8][6] &&
            workingPuzzle[8][7] == solvedPuzzle[8][7] &&
            workingPuzzle[8][8] == solvedPuzzle[8][8]
        )
        return true;
    else
        return false;
}

Answer 1

您需要了解循环。

关于使用索引映射将二维矩阵存储在一维数组中（比二维数组更易于处理）。

但是在这种情况下：

return java.util.Arrays.deepEquals(workingPuzzle, solvedPuzzle);

Answer 2

根据数组长度使用嵌套循环。

 public static boolean gameIsWon(int[][] workingPuzzle, int[][] solvedPuzzle) {
  if(workingPuzzle.length != solvedPuzzle.length) {
      return false; 
  }
  for(int i = 0; i < workingPuzzle.length; i++) {
    if(workingPuzzle[i].length != solvedPuzzle[i].length) {
      return false;
    }
    for(int j = 0; j < workingPuzzle[i].length; j++) {
      if(workingPuzzle[i][j] != solvedPuzzle[i][j]) {
          return false; 
      }
    }
  }
  return true;
}