Activity 5.5 — Two-Dimensional Arrays (2D Arrays)

Introduction

Activity 5.5

Two-Dimensional Arrays

What is a 2D array?

A 2D array is an array of arrays.
It looks like a grid (rows and columns).
Use it when data naturally fits a table.

1
// A 2D array is an "array of arrays"
2
int[][] grid =
3
{
4
    {3, 5, 7},
5
    {1, 4, 9},
6
    {8, 6, 2}
7
};
8

9
// Think: grid[row][col]

Vocabulary (Grid Thinking)

Row = which inner array
Column = which position inside the row
grid[row][col] accesses one element

Picture the Grid

For this array:

3 5 7
1 4 9
8 6 2

grid[0][0] = 3 (top-left)
grid[1][2] = 9 (row 1, col 2)
grid[2][1] = 6 (row 2, col 1)

Accessing One Element

Pick a row, then pick a column.

1
// Accessing one element
2
int value = grid[2][1]; // row 2, col 1
3
// value is 6

Row index comes first.
Column index comes second.

Two different lengths

grid.length = number of rows
grid[r].length = number of columns in row r
This prevents the #1 2D array bug.

1
// Common bug: mixing up row and col
2
// grid.length is # of rows
3
// grid[r].length is # of columns in row r

Traversal Step 1: One Row

Before scanning a whole grid, practice one row.

1
// Row traversal (one row)
2
for (int c = 0; c < grid[0].length; c++)
3
{
4
    System.out.println(grid[0][c]);
5
}

Traversal Step 2: Whole Grid

You need a loop for rows and a loop for columns.

1
// Full grid traversal (nested loops)
2
for (int r = 0; r < grid.length; r++)
3
{
4
    for (int c = 0; c < grid[r].length; c++)
5
    {
6
        System.out.println("grid[" + r + "][" + c + "] = " + grid[r][c]);
7
    }
8
}

Outer loop controls the row
Inner loop controls the column

Printing the Grid Nicely

Row by row, with spaces between columns.

1
// Printing a grid as rows
2
for (int r = 0; r < grid.length; r++)
3
{
4
    for (int c = 0; c < grid[r].length; c++)
5
    {
6
        System.out.print(grid[r][c] + " ");
7
    }
8
    System.out.println();
9
}

Algorithms on Grids

Sum all values (accumulator)
Count matches (if + counter)
Find max/min (best-so-far)
Row totals (reset sum each row)

Row Total Pattern

Reset the sum for each new row.

1
// Row sum pattern
2
int rowSum = 0;
3

4
for (int c = 0; c < grid[r].length; c++)
5
{
6
    rowSum += grid[r][c];
7
}

Find a Max in a Grid

Same idea as 1D, but inside nested loops.

1
// Finding a max value in a 2D array
2
int max = grid[0][0];
3

4
for (int r = 0; r < grid.length; r++)
5
{
6
    for (int c = 0; c < grid[r].length; c++)
7
    {
8
        if (grid[r][c] > max)
9
        {
10
            max = grid[r][c];
11
        }
12
    }
13
}

Practical Uses

Gradebook (students × assignments)
Steps tracker (people × days)
Seating chart (rows × seats)
Game boards (later)

Today's Work

Start simple: access + print
Move to algorithms: sum, max, count
Finish with mini apps: gradebook + seat map

'F' → Fullscreen

Objectives

Explain how a 2D array represents rows and columns.
Access and update values using grid[row][col].
Traverse a 2D array using nested for loops (row-major order).
Apply common algorithms (sum, max, counting, row totals) to a grid.

Activity Tasks

Create a new project named Activity5-5-2DArrays.
Complete Tasks 1-4. Tasks 5-6 are “mini apps” for extra practice.
Keep your loops correct: rows use grid.length, columns use grid[r].length.

Figures: Examples

1
// Figure 1 — A small 2D array you can picture as a grid
2
int[][] grid =
3
{
4
    {3, 5, 7},
5
    {1, 4, 9},
6
    {8, 6, 2}
7
};
8

9
// grid has 3 rows and 3 columns
10
// grid[0][0] is 3
11
// grid[1][2] is 9
12
// grid[2][1] is 6

1
// Figure 2 — Access + update one element
2
int[][] seats =
3
{
4
    {0, 0, 1, 0},
5
    {0, 1, 1, 0},
6
    {0, 0, 0, 0}
7
};
8

9
// 1 means occupied, 0 means empty
10
System.out.println(seats[1][1]); // prints 1
11

12
// Mark row 2, col 0 as occupied
13
seats[2][0] = 1;

1
// Figure 3 — Nested loop traversal template (Allman braces)
2
for (int r = 0; r < grid.length; r++)
3
{
4
    for (int c = 0; c < grid[r].length; c++)
5
    {
6
        // use grid[r][c]
7
    }
8
}

Task 1: Grid Basics (Access + Update)

Practice reading and changing a single element.
This builds confidence before nested loops.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        // Task 1 — Grid Basics (Access + Update)
6
        //
7
        // You are given a 3x3 grid of integers.
8
        // 1) Print the center element (row 1, col 1)
9
        // 2) Print the top-right element (row 0, col 2)
10
        // 3) Change the bottom-left element (row 2, col 0) to 99
11
        // 4) Print the updated bottom-left element to confirm
12

13
        int[][] grid =
14
        {
15
            {3, 5, 7},
16
            {1, 4, 9},
17
            {8, 6, 2}
18
        };
19

20
        System.out.println("Center (1,1): " + grid[1][1]);
21
        System.out.println("Top-right (0,2): " + grid[0][2]);
22

23
        grid[2][0] = 99;
24

25
        System.out.println("Updated bottom-left (2,0): " + grid[2][0]);
26
    }
27
}

Task 2: Print the Grid Nicely

Use nested loops to print the grid as rows and columns.
You should see a clean 3x3 table.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        // Task 2 — Print the Grid Nicely
6
        //
7
        // Print the grid so it looks like rows and columns.
8
        // Example:
9
        // 3 5 7
10
        // 1 4 9
11
        // 8 6 2
12

13
        int[][] grid =
14
        {
15
            {3, 5, 7},
16
            {1, 4, 9},
17
            {8, 6, 2}
18
        };
19

20
        for (int r = 0; r < grid.length; r++)
21
        {
22
            for (int c = 0; c < grid[r].length; c++)
23
            {
24
                System.out.print(grid[r][c] + " ");
25
            }
26
            System.out.println();
27
        }
28
    }
29
}

Task 3: Grid Stats (Sum, Max, Count)

Compute the sum of all values.
Find the max value in the grid.
Count how many values are even.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        // Task 3 — Grid Stats (Sum, Max, Count)
6
        //
7
        // Using traversal:
8
        // 1) Compute the sum of ALL values in the grid
9
        // 2) Find the maximum value
10
        // 3) Count how many values are even
11

12
        int[][] grid =
13
        {
14
            {3, 5, 7},
15
            {1, 4, 9},
16
            {8, 6, 2}
17
        };
18

19
        int sum = 0;
20
        int max = grid[0][0];
21
        int evenCount = 0;
22

23
        for (int r = 0; r < grid.length; r++)
24
        {
25
            for (int c = 0; c < grid[r].length; c++)
26
            {
27
                int value = grid[r][c];
28
                sum += value;
29

30
                if (value > max)
31
                {
32
                    max = value;
33
                }
34

35
                if (value % 2 == 0)
36
                {
37
                    evenCount++;
38
                }
39
            }
40
        }
41

42
        System.out.println("Sum: " + sum);
43
        System.out.println("Max: " + max);
44
        System.out.println("Even count: " + evenCount);
45
    }
46
}

Task 4: Row Totals (Weekly Steps)

Sum each row separately and print a weekly total per person.
Track the person with the highest total.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        // Task 4 — Row Totals (Practical: Weekly Steps)
6
        //
7
        // Each row is a person.
8
        // Each column is a day of the week (Mon-Sun).
9
        //
10
        // 1) Print each person's total steps for the week.
11
        // 2) Print which person (row index) had the highest weekly total.
12

13
        int[][] steps =
14
        {
15
            {5200, 6100, 4300, 7000, 8000, 12000, 9000},  // Person 0
16
            {8000, 7800, 8200, 7900, 8100, 8300, 7600},   // Person 1
17
            {3000, 4500, 5000, 4000, 6500, 7000, 6000}    // Person 2
18
        };
19

20
        int bestPerson = 0;
21
        int bestTotal = 0;
22

23
        for (int r = 0; r < steps.length; r++)
24
        {
25
            int rowSum = 0;
26

27
            for (int c = 0; c < steps[r].length; c++)
28
            {
29
                rowSum += steps[r][c];
30
            }
31

32
            System.out.println("Person " + r + " weekly total: " + rowSum);
33

34
            if (r == 0 || rowSum > bestTotal)
35
            {
36
                bestTotal = rowSum;
37
                bestPerson = r;
38
            }
39
        }
40

41
        System.out.println("Highest weekly total: Person " + bestPerson);
42
        System.out.println("Total steps: " + bestTotal);
43
    }
44
}

Task 5: Gradebook Mini App

Compute each student's average (row = student).
Let the user select a student and print their scores.

1
import java.util.Scanner;
2

3
public class Program
4
{
5
    public static void main(String[] args)
6
    {
7
        // Task 5 — Gradebook Mini App (Practical)
8
        //
9
        // Rows = students
10
        // Cols = assignments
11
        //
12
        // 1) Print each student's average.
13
        // 2) Ask the user for a student number (0-2) and print that student's scores.
14
        //
15
        // NOTE: We'll keep it small so it's easy to trace.
16

17
        int[][] grades =
18
        {
19
            {90, 82, 88, 100},   // Student 0
20
            {70, 85, 79, 92},    // Student 1
21
            {95, 91, 93, 89}     // Student 2
22
        };
23

24
        // 1) Student averages
25
        for (int r = 0; r < grades.length; r++)
26
        {
27
            int sum = 0;
28

29
            for (int c = 0; c < grades[r].length; c++)
30
            {
31
                sum += grades[r][c];
32
            }
33

34
            double avg = (double) sum / grades[r].length;
35
            System.out.println("Student " + r + " average: " + avg);
36
        }
37

38
        // 2) Lookup a student row and print their scores
39
        Scanner scanner = new Scanner(System.in);
40
        System.out.print("Enter a student number (0-2): ");
41
        int student = scanner.nextInt();
42

43
        if (student < 0 || student >= grades.length)
44
        {
45
            System.out.println("Invalid student number.");
46
        }
47
        else
48
        {
49
            System.out.print("Student " + student + " scores: ");
50
            for (int c = 0; c < grades[student].length; c++)
51
            {
52
                System.out.print(grades[student][c] + " ");
53
            }
54
            System.out.println();
55
        }
56

57
        scanner.close();
58
    }
59
}

Task 6: Seat Map Scanner

Count occupied and empty seats.
Print coordinates of all occupied seats.
This is a classic “scan a grid” pattern.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        // Task 6 — Seat Map (Practical + Visual)
6
        //
7
        // 0 means empty seat, 1 means occupied seat.
8
        //
9
        // 1) Count how many seats are occupied.
10
        // 2) Count how many seats are empty.
11
        // 3) Print the coordinates (row, col) of every occupied seat.
12
        //
13
        // This is a very common "grid scanning" pattern.
14

15
        int[][] seats =
16
        {
17
            {0, 0, 1, 0},
18
            {1, 1, 1, 0},
19
            {0, 0, 0, 0}
20
        };
21

22
        int occupied = 0;
23
        int empty = 0;
24

25
        for (int r = 0; r < seats.length; r++)
26
        {
27
            for (int c = 0; c < seats[r].length; c++)
28
            {
29
                if (seats[r][c] == 1)
30
                {
31
                    occupied++;
32
                    System.out.println("Occupied at (" + r + ", " + c + ")");
33
                }
34
                else
35
                {
36
                    empty++;
37
                }
38
            }
39
        }
40

41
        System.out.println("Occupied seats: " + occupied);
42
        System.out.println("Empty seats: " + empty);
43
    }
44
}

Sample Output

Your program output should something similar to the sample output below.

Center (1,1): 4
Top-right (0,2): 7
Updated bottom-left (2,0): 99

3 5 7
1 4 9
8 6 2

Sum: 45
Max: 9
Even count: 4

Person 0 weekly total: 51600
Person 1 weekly total: 55900
Person 2 weekly total: 36000
Highest weekly total: Person 1
Total steps: 55900

Student 0 average: 90.0
Student 1 average: 81.5
Student 2 average: 92.0
Enter a student number (0-2): 1
Student 1 scores: 70 85 79 92

Occupied at (0, 2)
Occupied at (1, 0)
Occupied at (1, 1)
Occupied at (1, 2)
Occupied seats: 4
Empty seats: 8

Reflection Questions

You may write your reflection answers as comments at the bottom of your code.

In a 2D array, what do rows and columns represent?
What is the difference between grid.length and grid[r].length?
Why do we use nested loops to traverse a 2D array?
In Task 4, why do we reset rowSum back to 0 for each new row?
What is one real-world situation where a 2D array makes sense?

Submission

Submit your activity and reflection answers to the appropriate dropbox.