
2D Arrays can be used to organize data into a grid, and with the appropriate methods, we can access and manipulate this data.

In the past two units, you've learned how to store data in an array or an ArrayList. Now it's time to take it to another dimension with 

. You can either think of them as a grid or as a nested array, and we'll use both methods of thinking in this unit. Using these, we'll learn how to set these up and also how to traverse them.

For this unit, we will first learn how to create and initialize 2D arrays with various types of objects. These will be nested arrays. When traversing a list, you need to use nested arrays for loops, and these will need to have proper bounds to avoid an 

. If you can master 2D arrays, you can easily do 3D and higher-dimensional arrays if you ever decide to continue using Java after this course!

 in much the same form as a regular array, but with some subtle differences. However, there are still two ways to do so. We can initialize an empty 2D array that fills the array with the same "null"/initialized values as when we use the regular arrays from Unit 6 (also called 

, where the two dimensions are clearly defined. We will talk more about this in the next subsection. 

/* Template: type[][] twoDArrayName = new type[firstDimension][secondDimension] */
int[][] arrayA = new int[3][4];

You can also initialize this with a pre-existing 2D array. This is similar to how you do 1D arrays. 

Here is an example of an int[3][4] 2D array but with values pre-initialized:

int[][] arrayB = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

You don't have to use integers for the type stored in the array. You can use any other primitive or reference type! Integers are only used in this guide for simplicity.

The 2D arrays can be represented in 2 major ways: one that is more visual, and one that is closer to how it is stored in the memory.

The first way to think about this is how it is stored in memory, or in terms of data structures. A 2D array in this form is just a 

 having arrays for its individual terms. In each inner array, the terms are objects or primitive type values of the type stated during initialization. When we initialize an array of type[firstDimension][secondDimension], we are actually initializing an array of length firstDimension (remember to use 

 as size is only for ArrayLists as in Unit 7). Each item in this array is another array containing secondDimension items of the specified type. For example, arrayA is an array with 3 items, each of which is an array with 4 integers.

A 2D array does not have to be rectangular. The inner arrays can vary in size. Here is an example of a non-rectangular array:

int[][] arrayC = {{1, 2}, {3}, {4, 5, 6}};

However, for the rest of this unit, we will be concerned with rectangular arrays, as those will be the type tested on the AP Exam.

Graphical Representation (only works for rectangular arrays)

For rectangular arrays, we can think of these as a 

 (if you have learned them in a prior math class). We can express arrayB from earlier as follows:

int[][] arrayB = {{1, 2, 3, 4},
                  {5, 6, 7, 8},
                  {9, 10, 11, 12}};

 . In this representation, firstDimension is the number of rows and secondDimension is the number of columns. Remember that arrayB is an example of an 

 2D array. Using the same logic, arrayB has 3 rows and 4 columns.

From this visual idea, we can easily find the 

 to access an individual element of a 2D array.

Indices for Elements in an int[3][4] Array

For indices, we use 2 bracketed numbers, called 

, with the first being the row and the second being the column. Remember that Java is a 

For a pre-initialized array, the number of rows is the length of the outer array, which is arrayName.length, while the number of columns is the length of each inner array, which for rectangular arrays is 

With double-index notation, we can access any element of the array. However, if you use an index that is not in the allowed range, you get an 

 means that we want the element in the third row and the fourth column, which corresponds to 12. Lets do a little practice using arrayB from above:

What are the indices for the following:
1. 6
2. 4
3. 9
4. 5
What values are given for the following indices:
5. [1][3]
6. [0][2]
7. [3][2]
8. [2][0]

1. [1][1] (2nd row, 2nd column)
2. [0][3] (1st row, 4th column)
3. [2][0] (3rd row, 1st column)
4. [1][0] (2nd row, 1st column)
5. 8 (2nd row, 4th column)
6. 3 (1st row, 3rd column)
7. The last row in the array has row index 2, since there is no fourth row 
   with index 3, an ArrayIndexOutOfBoundsException is thrown
8. 9 (3rd row, 1st column)

We will use the graphical representation of 2D arrays in the rest of this unit as it is easier to visualize and understand.

AP Computer Science A Exam

AP CSA Exam Prep 2020 | Reviews + Free Study Help | Fiveable

AP Computer Science A

Free Reviews

Unit 1: Primitive Types

Unit 2: Using Objects

Unit 3: Boolean Expressions and if Statements

Unit 4: Iteration

Unit 5: Writing Classes

Unit 6: Array

Unit 7: ArrayList

Unit 8: 2D Array

Unit 9: Inheritance

Unit 10: Recursion

Blogs

First Unit

Unit 8 Overview and 8.1 2D Arrays

Note: In this topic, we will be using arrayB and the graphical representation of 2D arrays from the previous topic. As a reminder, here is arrayB:

Recall that when traversing a 1D array, you use a loop, usually a 

. This is similar to how we traverse 2D arrays, except in 2D arrays, we need 

, an outer loop traversing through one dimension, and an inner loop traversing through the other. Here is the general form:

for (firstDimension traversal conditions) {
  for (secondDimension traversal conditions) {
    System.out.print(item + " ");
  }
}
System.out.println();

There are two main directions we can traverse through. The first is 

, traversing through every element in one row before moving to the next. Conversely, there is 

, traversing through every element in one column before moving on to the next. 

We will focus on traversing in a forward direction (from left-to-right and from top-to-bottom) in this section. In the next, we will go in reverse directions, but this will only require a change in the for loop conditional.

When doing row-wise traversal, the outer loop traverses through the different rows, and the inner loop traverses through the elements in each row. Here is how you write code for this:

public static void rowWiseForward(int[][] array) {
  for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[0].length; j++) {
      System.out.print(array[i][j] + " ");
    }
  }
}

public static void main(str[] args) {
  columnWiseForward(arrayB);
}

 for forward row-wise traversals. Here is the code that creates the same output as above, only this time using enhanced for loops instead of regular for loops:

public static void rowWiseForwardEnhancedForLoops(int[][] array) {
  for (int[] row: array) {
    for (int number: row) {
      System.out.print(number + " ");
    }
  }
}

Remember that the type of the rows in the 2D array are 1D arrays, and the rows contain elements of a certain type!

When doing column-wise traversal, the outer loop traverses through the different columns, and the inner loop traverses through the elements in each columns. Here is how you write code for this:

public static void columnWiseForward(int[][] array) {
  for (int i = 0; i < array[0].length; i++) {
    for (int j = 0; j < array.length; j++) {
      System.out.print(array[j][i] + " ");
    }
  }
}

public static void main(str[] args) {
  columnWiseForward(arrayB);
}

We can see that the two traversal algorithms using regular for loops are almost the same. The only significant difference is with the order of the 

. However, the loop conditional for traversing through different rows is the same in both cases, and so is the conditional for traversing through different columns. Here are the conditionals for the two different traversal directions:

We will use this to help us go in reverse next!

Sometimes, we want to traverse across the rows from right to left, or traverse across the columns from bottom to top. This will require a change the for loop headers, as follows:

This is initializing i to the last row, and then going up row-by-row to the first row in every loop iteration.

Likewise, this is initializing i to the rightmost column, and then going left column-by-column to the first column in every loop iteration.

To do row-wise traversal, put the row for loop header first, while to do column-wise traversal, put the column for loop header first.

Let's do a challenge. We want to traverse arrayB so that it prints the following:

1. 1 2 3 4 8 7 6 5 9 10 11 12
2. 12 8 4 3 7 11 10 6 2 1 5 9

For example 1, we are doing a row-wise traversal from top to bottom that starts forward, but then alternates the direction every row as shown in this image:

For example 2, we are doing a column-wise traversal from right to left that starts backwards then alternates in direction as is shown in this image:

What's the secret behind this? It's an if statement and modulo. Here is the code with the this part commented:

public static void exampleOne(int[][] array) {
  for (int i = 0; i < array.length; i++) {
    if (i % 2 == 0) { // we use an if statement with modulo base 2 to alternate
      for (int j = 0; j < array[0].length; j++) {
        System.out.print(array[i][j] + " ");
      }
    } else {
      for (int j = array[0].length - 1; j >= 0; j--) {
        System.out.print(array[i][j] + " ");
      }
    }
  }
}

public static void exampleTwo(int[][] array) {
  for (int i = array[0].length; i >= 0; i--) {
    if (i % 2 == 0) { // we use an if statement with modulo base 2 to alternate
      for (int j = 0; j < array[0].length; j++) {
        System.out.print(array[j][i] + " ");
      }
    } else {
      for (int j = array.length - 1; j >= 0; j--) {
        System.out.print(array[j][i] + " ");
      }
    }
  }
}

For 2D arrays, we use the slightly modified versions of the algorithms we have been doing with 1D arrays and ArrayLists. All of these algorithms apply the loop traversals we have just discussed! Here, we will have a snippet for each algorithm you are expected to know with each snippet annotated for you.

/** Prints the row and column indices if the element is in the array and -1 if not
*/
public static boolean searchForElement(int[][] array, int elementToSearch) {
  flag = false; //sets flag to see if element has been found
  for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[0].length; j++) { //traverses through the array
      if (array[i][j] == elementToSearch) {
        System.out.println("Row " + i);
        System.out.println("Column " + j); //if element found, print coordinates 
        flag = true; //element has been found
      }
    }
  }
  if (!flag) { //if element not found, print -1
    System.out.println(-1);
  }
}

/** Doubles each element of the array
*/
public static void doubleArray(int[][] array) {
  for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[0].length; j++) {
      array[i][j] *= 2; // doubles each individual element
    }
  }
}

Note that in the above snippet, we used regular for loops instead of enhanced for loops. Here, we cannot use enhanced for loops as follows:

/** Doubles each element of the array
*/
public static void doubleArray(int[][] array) {
  for (int[] row: array) {
    for (int number: row) {
      number *= 2; // doubles number
    }
  }
}

 In the first example, we are actually accessing the array itself. However, in the enhanced for loop example, we are making a copy of that array and any changes are affecting the copy, not the actual array.

However, if the array items are objects and we are changing the value of one of the object's instance variables, we can use enhanced for loops as the copy contains references to the actual objects themselves. Here is an example of this:

/** Represents a student
*/
public class Student {
  private String name;
  
  /** Sets the name of the Student
  */
  public void setName(String name) {
    this.name = name;
  }

  /** Other instance variables, methods, and constructors not shown
  */
}
// IN ANOTHER CLASS
/** Resets names of all student s 
*/
public static void doubleArray(Student[][] array, String defaultName) {
  for (Student[] row: array) {
    for (Student student: row) {
      student.setName(defaultName); // Sets each student's name to a default name
    }
  }
}

/** Inserts all the values in the array into an ArrayList
*/
public static ArrayList<Integer> putIntoArrayList(int[][] array) {
  ArrayList<Integer> intList = new ArrayList<Integer>(); //makes an empty ArrayList
  for (int[] row: array) {
    for (int number: row) {
      intList.add(new Integer(number)); //Boxes the integer to an Integer object
    }                                   //adding it to the ArrayList
  }
  return intList;
}

/** Inserts all the values in the array into an ArrayList
*/
public static int[] putIntoArray(int[][] array) {
  int[] intArray = new int[array.length * array[0].length]; //initialize the array
  for (int i = 0; i < array.length; i++) {    //to the number of items in rect array
    for (int j = 0; j < array[0].length; j++) {
      intArray[i*array[0].length + j] = array[i][j]; //i*array[0].length + j 
    }                                                //is the nth item
  }
  return intArray;
}

/** Finds the maximum
*/
public static int maximum(int[][] array) {
  int maxValue = array[0][0];
  for (int[] row: array) {
    for (int number: row) {
      if (number > maxValue) { //if new max value found, replace current maxValue
        maxValue = number;
      }
    }
  }
  return maxValue;
}

/** Finds the minimum
*/
public static int minimum(int[][] array) {
  int minValue = array[0][0];
  for (int[] row: array) {
    for (int number: row) {
      if (number < minValue) { //if new min value found, replace current minValue
        minValue = number;
      }
    }
  }
  return minValue;
}

Join our community

Unit 8: 2D Array

AP Computer Science A

all

study guides

browse by units

Free Reviews

Unit 1: Primitive Types

Unit 2: Using Objects

Unit 3: Boolean Expressions and if Statements

Unit 4: Iteration

Unit 5: Writing Classes

Unit 6: Array

Unit 7: ArrayList

Unit 8: 2D Array

Unit 9: Inheritance

Unit 10: Recursion

Blogs

Join Our Community

Unit 8: 2D Array

AP Computer Science A

all

study guides

browse by units

Free Reviews﻿

Unit 1: Primitive Types﻿

Unit 2: Using Objects﻿

Unit 3: Boolean Expressions and if Statements﻿

Unit 4: Iteration﻿

Unit 5: Writing Classes﻿

Unit 6: Array﻿

Unit 7: ArrayList﻿

Unit 8: 2D Array﻿

Unit 9: Inheritance﻿

Unit 10: Recursion﻿

Blogs﻿

Join Our Community

Free Reviews

Unit 1: Primitive Types

Unit 2: Using Objects

Unit 3: Boolean Expressions and if Statements

Unit 4: Iteration

Unit 5: Writing Classes

Unit 6: Array

Unit 7: ArrayList

Unit 8: 2D Array

Unit 9: Inheritance

Unit 10: Recursion

Blogs