Lecture Notes 14: Intro to 2-D Arrays

Objectives

By the end of this module, you will:

Demonstrate the decclaration and initialization of two-dimensional arrays.
Construct nested loops to traverse, access, and manipulate two-dimensionl arrays.
Explain the abstract representation of a 2-D array and the role each part plays (references, addresses, cells, indices, and values).
Recognize the way multi-dimensional arrays extend to more than 2 dimensions.
Read code examples with multidimensional arrays, learning about both declaration and access, and the types of bugs that might arise.

Before Starting

Read Sections 14.01 to 14.03 in the Codio Course

If you do not have your Codio course ready, use any text editor or simple IDE. Some possibilities are:

Write using Sublime; Compile and run in the Terminal
Use IDEs like: IntelliJ, DrJava, or JGrasp

Catching Up

Before we move forward, let's catch up (complete any remaining work from the previous module)
In this case, make sure we've got:

One-Dimensional Arrays... Declaring, Initializing, and Accessing!

Objectives

By the end of this module, you will:

Read code examples with multidimensional arrays, learning about both declaration and access.
See examples of using multidimensional arrays.
Understand when lists might be preferable to arrays.
Read code examples that use lists.
Learn a little about objects and what they mean.
Understand what the term byte means and how to work with bytes in Java.
Learn how to download and use an external (third party) Java software library.

Two dimensional (2D) arrays

Let's start with a an example of a 1D array of Strings, each of which has characters at a different index. This is NOT a proper 2D array, but it can be worked as such.

Let's use word squares as an example:

We wish to determine whether a group of strings

  String[] words = {"bard", "area", "rear", "dart"};
  System.out.println ( isWordSquare(words) );

is a word square, as in

     b a r d
     a r e a
     r e a r
     d a r t

where each row is the same as its corresponding column.

Activity 1: In MyWordSquare.java use charAt() to solve this problem. That is, write a method called isWordSquare(String[] words) that returns true or false, depending on whether the words form a valid word square. Then, in main() write the above two lines of code to test.

Now With an actual 2D Array of Chars

Let's now look at how two-dimensional (2D) arrays can be used for this problem:

    public static void main (String[] argv)
    {
      char[][] letters = {
          {'b', 'a', 'r', 'd'},
          {'a', 'r', 'e', 'a'},
          {'r', 'e', 'a', 'r'},
          {'d', 'a', 'r', 't'}
        };

      System.out.println ( isWordSquare(letters) );
    }

    static boolean isWordSquare (char[][] letters)
    {
      for (int i=1; i<letters.length; i++) {
          for (int j=0; j<letters.length; j++) {
            if (letters[i][j] != letters[j][i]) {
              return false;
            }
          }
      }

      return true;
    }

Notice how a 2D area is declared:
```
  char[][] letters = ...
     
```
An integer 2D array would be declared similarly:
```
  int[][] someNumbers = ...
     
```

Next, recall how 1D arrays were initialized with values:

  char[] someLetters = {'b', 'a', 'r', 'd'};

A 2D static initialization is similar except that it's now a collection of 1D arrays (separated by commas):

  char[][] letters = {
      {'b', 'a', 'r', 'd'},
      {'a', 'r', 'e', 'a'},
      {'r', 'e', 'a', 'r'},
      {'d', 'a', 'r', 't'}
    };

The newlines are not needed. We just organized it so it is easy to read. It could also be declared like this, and the result would be the same (scroll to see complete):
```
char[][] letters={{'b','a','r','d'},{'a','r','e','a'},{'r','e','a','r'},{'d','a','r','t'}};
     
```
Lastly, 2D arrays are addressed by two integers, one for the "row" and one for the "column".

Thus

  letters[1][2]

refers to the element in row 1 (2nd row) and column 2 (3rd column):

  char[][] letters = {
      {'b', 'a', 'r', 'd'},
      {'a', 'r', 'e', 'a'},
      {'r', 'e', 'a', 'r'},
      {'d', 'a', 'r', 't'}
    };

Another way to think about it:

The first number refers to a whole array.

Thus

  letters[1]

refers to the 1D array in position 1 of the array of rows:

  char[][] letters = {
      {'b', 'a', 'r', 'd'},
      {'a', 'r', 'e', 'a'},
      {'r', 'e', 'a', 'r'},
      {'d', 'a', 'r', 't'}
    };

Which means that
```
  letters[1][2]
     
```
refers to the element ('e') in position 2 of that 1D array.

For dynamic declaration and initializations, we can do something similar than with 1-D arrays.
- First, we declare the variable that will hold the reference:
```
    char[][] letters;
       
```
- Then, we initialize the spacec that will hold the values:
```
    letters = new char[4][4];
        
```
- Lastly, we'd need to access each cell adn assign the values we want:
```
    letters[0][0] = 'b';
    letters[0][1] = 'a';
    // ...
       
```
- As with 1-D arrays, we can do the declaration and initialzation in a single statement:
```
    char[][] letters = new char[4][4];
       
```

Let's print out the word square:

  for (int i=0; i<letters.length; i++) {
      for (int j=0; j<letters.length; j++) {
          // Use print so that the row appears on one line:
          System.out.print (letters[i][j]); 
      }
      // Go to next line for next row:
      System.out.println ();
  }

We could choose to print the elements of the main diagonal: top-left(TL) to bottom-right(BR) as in:

  for (int i=0; i<letters.length; i++) {
      System.out.print (letters[i][i]);
  }
  System.out.println ();

Activity 2: In MyWordSquare2.java print the whole square, and both diagonals (TL-to-BR and BL-to-TR).

Dealing with rectangles:

In the above example, the size of a row was exactly equal to the size of a column.

Thus, in

  for (int i=1; i<letters.length; i++) {
      for (int j=0; j<letters.length; j++) {
          // ... printing/whatever ...
      }
  }

we have the same upper limit for both rows and colums.

But what happens when they are different?

For this case, we need to modify the inner loop's limit:

  char[][] letters = {
      {'f','r','a','c','t','u','r','e'},
      {'o','u','t','l','i','n','e','d'},
      {'b','l','o','o','m','i','n','g'},
      {'s','e','p','t','e','t','t','e'}
    };

  for (int i=1; i<letters.length; i++) {
      for (int j=0; j<letters[i].length; j++) {
          // ... 
      }
  }

Recall that the first index refers to the whole row so that
```
      letters[i]
     
```
is the whole row and therefore has a length:
```
      letters[i].length
     
```

We could define non-rectangular arrays if we chose to:

  int[][] A = {
      {1},
      {2,2},
      {3,3,3},
      {4,4,4,4}
    };

  for (int i=0; i<A.length; i++) {
      for (int j=0; j<A[i].length; j++) {
          System.out.print (A[i][j]);
      }
      System.out.println ();
  }

Activity 3: In PoorPrintExample.java print this array:

  int[][] A = {
      {1, 2, -3, 4},
      {1, 22, 333, 4444},
      {4, -5, 66, 777}
    };

In the above example, you saw the the result was an unappealing jagged print.

We will instead use printf to neatly print a 2D array:

  for (int i=0; i<A.length; i++) {
      for (int j=0; j<A[i].length; j++) {
          System.out.printf (" %5d", A[i][j]);
      }
      System.out.println ();
  }

Here, the format specification string
```
    System.out.printf (" %5d", A[i][j]);
     
```
specifies 5 digits for an integer after a space.
The letter code "d" refers to an integer.
Recall: the letter code "f" refers to a double.
For example, if the array were a double array, we could use
```
    System.out.printf (" %8.3f", A[i][j]);
     
```
to specify a total of 8 digits with 3 after the decimal point.

Activity 4: In NicePrintExample.java print this array neatly:

  double[][] A = {
      {1.1, 2.222, -3.3, 4.4444},
      {1.0, 2.2, 33.3, 444.4},
      {0.4, -5.0, 0.66, 0.0777}
  };

CS 1111

Lecture Notes 14: Intro to 2-D Arrays

Objectives

Before Starting

Catching Up

Objectives

Two dimensional (2D) arrays

Now With an actual 2D Array of Chars