Java-2D数组检查对角线数字板

目前，我正在开发一个程序，该程序在8x8 2D阵列板中生成随机0和1。我要做的是检查对角线上的所有数字是否相同（从角开始，而不仅仅是任何对角线）

例如：

int[][] array = {
    {0, 0, 0, 0, 0, 0, 0, 1},
    {0, 0, 1, 0, 1, 0, 1, 0},
    {0, 0, 0, 0, 1, 1, 1, 0},
    {0, 0, 0, 0, 1, 1, 1, 0},
    {0, 0, 1, 1, 0, 1, 1, 0},
    {0, 0, 1, 0, 0, 0, 1, 0},
    {0, 1, 0, 0, 0, 0, 0, 0},
    {1, 0, 0, 1, 1, 1, 1, 0}
};

因此，如果碰巧从左上角（0,0）、（1,1）…（7,7）开始的所有数字都是0或1，那么我必须输出到扫描仪，指示“有一个0的主对角线”（来自上面的示例）

同样从这个例子中，我们可以看到，从右上角，数字“1”朝左下角对角重复，然后我还必须显示“有一个小对角线1”

到目前为止，我已经知道如何生成数字并将其输入到数组中，但我不知道如何检查。这就是我到目前为止所做的：

public class JavaTest{
// Main method
public static void main(String[] args) {

    int[][] array = {
        {0, 0, 0, 0, 0, 0, 0, 1},
        {0, 0, 1, 0, 1, 0, 1, 0},
        {0, 0, 0, 0, 1, 1, 1, 0},
        {0, 0, 0, 0, 1, 1, 1, 0},
        {0, 0, 1, 1, 0, 1, 1, 0},
        {0, 0, 1, 0, 0, 0, 1, 0},
        {0, 1, 0, 0, 0, 0, 0, 0},
        {1, 0, 0, 1, 1, 1, 1, 0}
    };

    // Print array numbers
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++)
            System.out.print(array[i][j] + " ");
        System.out.println();
    }
    // Print checkers

    checkMajorDiagonal(array);
}
// Check major diagonal 
public static void checkMajorDiagonal(int array[][]) {
    int majDiag;
    boolean isMatching = true;
    int row = 0;
    for(row = 0; row < array.length; row++){
        majDiag = row;
        if(array[row][row] != array[row+1][row+1]){
            isMatching = false;
            break;
        }
    }
    //If all elements matched print output
    if(isMatching)  
        System.out.println("Major diagonal is all " + array[row][row]);
    }
}

公共类JavaTest{
//主要方法
公共静态void main（字符串[]args）{
int[][]数组={
{0, 0, 0, 0, 0, 0, 0, 1},
{0, 0, 1, 0, 1, 0, 1, 0},
{0, 0, 0, 0, 1, 1, 1, 0},
{0, 0, 0, 0, 1, 1, 1, 0},
{0, 0, 1, 1, 0, 1, 1, 0},
{0, 0, 1, 0, 0, 0, 1, 0},
{0, 1, 0, 0, 0, 0, 0, 0},
{1, 0, 0, 1, 1, 1, 1, 0}
};
//打印阵列号
for（int i=0；i

---

虽然到目前为止我所做的并没有像我希望的那样工作，因为有一个错误，我仍然需要做小对角线。提前感谢。

错误可能是因为您在row 要检查小对角线，请尝试类似的方法：

int maxIndex = array.length - 1;
for(row = 0; row < maxIndex; row++){
  majDiag = row;
  if(array[row][maxIndex - row] != array[row+1][maxIndex - (row+1)]){
    isMatching = false;
    break;
  }
}

intmaxindex=array.length-1；
对于（行=0；行

int对角线值=0；
对于（int i=0；i<8；i++）{
对角线值=数组[i][j]；
对于（int j=0；j<8；j++）
如果（i==j）{
if（数组[i][j]==对角线值）{
计数器++；
} 
其他的
打破
}
}
}
if（counter==8）//是，它们是相同的，否则不是

---

将数组的大小（即9）保留在变量中，使其松散耦合。

有关方法的一些要点

checkmajordangal

：

int majDiag;
boolean isMatching = true;
int row = 0;
for(row = 0; row < array.length; row++){
    majDiag = row;   //not being used anywhere
    if(array[row][row] != array[row+1][row+1]){ //out of bounds with row+1
        isMatching = false;
        break;
    }
}

次要对角线逻辑：

for(row = 0; row < array.length; row++){
  for(col = 0; col < array[i].length; col++){
         if(row+col==array[i].length){
                 array[row][col] // this would be your minor diagonal element row wise
  }
}

for（行=0；行

如果您使用的是Java 8，那么您可以通过流执行此操作，而不是手动迭代这些值。这可能是一种比检查以前的值更直接的方法

if (IntStream.range(0, size).map(n -> array[n][n]).allMatch(n -> n == 0)) {
}

if (IntStream.range(0, size).map(n -> array[n][size-n-1]).allMatch(n -> n == 1)) {
}

---

已经有很多答案了。这里还有一种方法。你的方法是正确的，但是没有必要通过检查对角线元素和下一个元素等等来使事情复杂化。只需用第一个对角线元素检查每个对角线元素。一旦发现差异，你就停止检查

 public static void checkDiagonal(int[][] array){

     // Start with the assumption that both diagonals are consistent.
     boolean majorConsistent = true; 
     boolean minorConsistent = true;

     int length = array.length;

     int tempMajor = array[0][0];        // all elements in the Major must be equal to this
     int tempMinor = array[0][length-1]; // all elements in the Minor must be equal to this

     // Check major diagonal, and update the boolean if our assumption is wrong.
     for(int i=0; i<length; i++){ 
         if (array[i][i] != tempMajor) { //(0,0);(1,1);(3,3);...
             majorConsistent = false;
             break;
         }
     }

     // Check minor diagonal, and update the boolean if our assumption is wrong.
     for(int i=0,j=length-1; i<length; i++,j--){
         if (array[i][j] != tempMinor) { //(0,7);(1,6);(2,5);...
             minorConsistent = false;
             break;
         }
     }

     System.out.println("Major elements all same = "+majorConsistent);
     System.out.println("Minor elements all same = "+minorConsistent);

 }

publicstaticvoidcheckdiagonal（int[][]数组）{
//首先假设两条对角线是一致的。
布尔majorConsistent=true；
布尔值minorConsistent=true；
int length=array.length；
int tempmain=array[0][0]；//主数组中的所有元素都必须等于
int tempMinor=array[0][length-1]；//次数组中的所有元素都必须等于此值
//检查主对角线，如果我们的假设错误，则更新布尔值。
对于（int i=0；我谢谢你。但是我如何开始使用小对角线？请注意，我的小对角线解决方案（如上）肯定更有效（O（n）而不是O（n平方））。但是，对于这种情况，这可能无关紧要。
if (IntStream.range(0, size).map(n -> array[n][n]).allMatch(n -> n == 0)) {
}

if (IntStream.range(0, size).map(n -> array[n][size-n-1]).allMatch(n -> n == 1)) {
}

 public static void checkDiagonal(int[][] array){

     // Start with the assumption that both diagonals are consistent.
     boolean majorConsistent = true; 
     boolean minorConsistent = true;

     int length = array.length;

     int tempMajor = array[0][0];        // all elements in the Major must be equal to this
     int tempMinor = array[0][length-1]; // all elements in the Minor must be equal to this

     // Check major diagonal, and update the boolean if our assumption is wrong.
     for(int i=0; i<length; i++){ 
         if (array[i][i] != tempMajor) { //(0,0);(1,1);(3,3);...
             majorConsistent = false;
             break;
         }
     }

     // Check minor diagonal, and update the boolean if our assumption is wrong.
     for(int i=0,j=length-1; i<length; i++,j--){
         if (array[i][j] != tempMinor) { //(0,7);(1,6);(2,5);...
             minorConsistent = false;
             break;
         }
     }

     System.out.println("Major elements all same = "+majorConsistent);
     System.out.println("Minor elements all same = "+minorConsistent);

 }