Java二维数组布尔值

Question

My homework is to create a (not so) simple recreation of Conway's Game of Life. Exact Instructions:

1. Prompt the user to enter a list of (i,j) pairs (both non-negative integers) (stop when a negative integer is read for either i or j)
2. Prompt the user to enter the number of time steps
3. Initialize the grid based on the (i,j) pairs entered by the user
4. Display the initial state of the grid (call the displayGrid() method)
5. For each time step, update the grid according to Conway's rules (call the updateGrid() method) and display the grid (call the displayGrid() method)

My programs output has now changed:

Please enter list of (i, j) pairs for populated cells(negative i or j to quit):
6 4 6 5 6 6 6 7 6 8
-1 -1
Enter number of time steps:
2
Initial Grid:






   ######



Time step 1










Time step 2

My new question is what is making my code "kill" everything? Why isn't there any "true"s?

Here's my code:

java.util.Scanner;

  class P8{
    public static void main(String[] args){
       Scanner in = new Scanner(System.in);
       boolean[][] multi = new boolean[10][10];
       int i, j, N, x, y, h;

       for(x=1; x<multi.length; x++){
          for(y=1; y<multi.length; y++){
             multi[x][y] = false;
          }
       }
       System.out.println("Please enter list of (i, j) pairs for populated cells(negative i or j to quit):");

       while(true){
          i = in.nextInt();
          j = in.nextInt();
          if(i <= 0 || j <= 0){
             break;}

          multi[i][j] = true;
          }

       System.out.println("Enter number of time steps:");
       N = in.nextInt();
       System.out.println("Initial Grid: \n");
       displayGrid(multi);
       for(i = 1; i<N+1; i++){
          System.out.printf("Time step %d\n", i);
          updateGrid(multi);
          displayGrid(multi);
          System.out.println("\n");
       }
 }

       /******************************************
       void updateGrid(boolean mat[][]); updates
       the 2 dimensional array using Conway's
       standard rules. Does this by calling
       "neighbors" function
       ******************************************/
       public static void updateGrid(boolean mat[][]){
          boolean[][] temp = new boolean[mat.length][mat.length];
          int i, j, row, col, n=0;

          for(row = 0; row < mat.length; row++){
             for(col = 0; col < mat.length; col++){
             neighbors(mat, row, col);

             if(n>=4 || n<=1)
                mat[row][col] = false;
             else
                mat[row][col] = true;

             }
          }
       }

       /******************************************
        void neighbors(boolean mat[][]int row, int col) 
        checks how many "neighbors" are around a given point
       ******************************************/
        public static int neighbors(boolean mat[][], int row, int col){
           int N =0;
           if((row-1 >= 0)&&(col-1 >= 0))
              N = mat[row-1][col-1] ? N + 1 : N;

           if((row >=0)&&(col-1 >= 0))
              N = mat[row][col-1] ? N+1 : N;

           if((row+1 < mat.length)&&(col-1 >= 0))
              N = mat[row+1][col-1] ? N+1 : N;

           if((row+1 < mat.length)&&(col < mat[0].length))
              N = mat[row+1][col] ? N+1 : N;

           if((row+1 < mat.length)&&(col+1 < mat[0].length))
              N = mat[row+1][col+1] ? N+1 : N;

           if((row < mat.length)&&(col+1 < mat[0].length))
              N = mat[row][col+1] ? N+1 : N;

           if((row-1 >= 0)&&(col+1 < mat[0].length))
              N = mat[row-1][col+1] ? N+1 : N;

           if((row-1 >= 0)&&(col < mat[0].length))
              N = mat[row-1][col] ? N+1 : N;

            return N;
       }

       /******************************************
        void displayGrid(int mat[][]) prints out
        a two dimensional array
       ******************************************/
       public static void displayGrid(boolean mat[][]){
          int x, y;
          for(x=1; x<mat.length; x++){
             for(y = 1; y<mat.length; y++){
                if(mat[x][y])
                   System.out.printf("#");
                else
                   System.out.printf(" ");
             }
             System.out.println();
          }

       }
  }

`

Answer 1

My question is where in my code is multi[][] becoming all 'true' since that's the criteria I have to print '#'

In your displayGrid method.

if(mat[x][y]= true) is an assignment, not a comparison.

Use

if (mat[x][y])

instead.

You never need to write bool == true (or bool == false ), because you can write them more easily as bool (and !bool ) - and the latter forms avoid the potential for missing out one of the = signs and changing the semantics of the expression.