Build it step by step

Every step below leaves a scenario that compiles and runs. If you stop halfway you will have something that works, not something broken. Follow along in Greenfoot rather than reading straight through.

1. Step 1

   On your screen A grid diagram showing three rows of four columns with every cell containing zero.

   int[][] grid = new int[3][4];

   Two pairs of parentheses: an array of arrays.

   `new int[3][4]` builds 3 ROWS of 4 COLUMNS. Rows first, always.

   Every cell starts at zero, just as with a 1D array. Twelve cells, all zero.

2. Step 2

   On your screen A 2D array written as a literal grid in nested braces, laid out to look like the map it represents.

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

   This is the form you will use for the rest of the course, and it is the reason 2D arrays are so good for level design: THE CODE LOOKS LIKE THE MAP.

   Four rows, five columns. 1 is a wall, 0 is floor, and you can see the room with a hole in the middle just by reading it.

   Lay it out with one row per line, always. Squashed onto one line it is unreadable and the whole advantage is lost.

3. Step 3

   On your screen The length of the outer array and of one inner row shown separately.

   map.length       // 4, the number of ROWS
   map[0].length    // 5, the number of COLUMNS in row 0

   Two different lengths, and confusing them is a common source of transposed maps.

   `map.length` counts the ROWS, because the outer array holds rows. `map[0].length` counts the columns, because `map[0]` IS a row, and a row is a 1D array with its own length.

   That is the array-of-arrays idea made concrete: `map[0]` is not a value, it is a whole array.