Java Programming:

From the Ground Up

Chapter 7
Arrays and Lists:
One Name for Many Data
 Arrays

• An array is a named sequence of contiguous memory

locations capable of holding a collection of data of the same
type.

• Unlike the variables of previous programs, an array can store

more than one value.

• An array can store a list of thousands or even millions of data

A variable in contrast to an array
 Array Declaration

• type[] name:

 type is a data type such a int, char, double or boolean

 name is a valid Java identifier that provides a name to
an array

• int[] myArray and double[] yourArray:

 The variables myArray and yourArray are reference

variables.
 A reference variable does not hold an integer, a floating
point number, a character or a boolean value.
 A reference variable holds a memory address.
 Array Declaration

• Java provides two types of variable primitive and reference:

 A primitive variable stores a single value of type byte,

short, int, long, float, double, boolean, or char.

 A reference variable holds a memory address or

reference.

• Each of the two variables myArray and yourArray, when

assigned a value, holds a memory address, the address of
the first cell of a block of storage locations
 Array Instantiation

• The references myArray and yourArray are uninitialized.

• A declaration does not create an array.

• Once an array reference is declared, memory for the array

must be allocated.
 Array Instantiation

• An array is created or instantiated via the new operator:

 type [] name; // declaration

 name = new type[size]; // array instantiation
 or
 type[] name = new type[size] // declaration and
instantiation

• type is a data type and size is a positive integer or any

expression that evaluates, or is automatically converted, to a
positive integer.

• The integer size indicates the length of the array, i.e., the
number of cells in the array.
 Array Instantiation

• The values held in an array must all be the same data type.

• When an array is created, each cell is automatically given a unique name

.
• The names of the cells of the array referenced by myArray are
myArray[0], myArray[1], myArray[2], myArray[3], and myArray[4]. In this
case, the array is indexed from 0 to 4.

• The first index of every array is 0.

 Array Instantiation

• When an array is instantiated, each memory cell is initialized

with the “zero value” of its data type.

• Thus every cell of an array of int or char data is initialized to

0 and all cells of an array of doubles are set to 0.0.

• Each cell of a boolean array is initialized to false.

 Array Instantiation

int [] numberList;
numberList = new double[5];
**********
numberList refers to an array of 5 integers
Each array cell is initialized to 0
 Array Instantiation

System.out.println("Enter array size: ");

int size = input.nextInt();
double [] decimals;
decimals = new double[size];
**********
The length of the array (size) is supplied at runtime.
The name decimals refers to an array of doubles.
Each memory cell is initialized to 0.0.
 Array Instantiation

int x = 3;
char [] letters = new char[2*x];
**********
letters refers to an array of char data.
Each memory cell is initialized to 0.
 Array Instantiation

• Once an array is created, its length is fixed.

• The length of an array cannot be altered.

• If variable x refers to an array, then x.length

gives the number of memory cells allocated to
the array.
 Using an Array

• You can use array variables in assignment statements or any

expression.

The statement:

int[] numbers = new int[5]

declares and instantiates an array named numbers such that:

• numbers is indexed from 0 to 4.

• numbers is capable of storing 5 integers in locations numbers[0],

numbers[1], numbers[2], numbers[3], and numbers[4].

• numbers.length has the value 5.

• the initial value stored in each cell of numbers is 0.

 Using an Array

Each memory cell is a variable:

• numbers[0] = input.nextInt(); // reads a value into numbers[0]

• numbers[1] = 213 + numbers[1]; // adds 213 to numbers[1]

• System.out.println(5*numbers[1] + 3*numbers[0]);
 Using an Array

Program statement:

• Write a program that prompts for 10 integers and displays those same numbers
in reverse order. For example, if you enter the numbers:

0 11 2 33 4 55 6 77 8 99

the program’s output is:

99 8 77 6 55 4 33 2 11 0
 Solution

• The following application stores 10 integers in an array

named list.

• The array consists of 10 memory cells that are named

list[0], list[1]...list[9]. The user supplies 10 numbers.

• The numbers are stored in these 10 cells and finally, the

numbers are displayed in reverse order.
1. import java.util.*;
2. public class ReverseList
3. {
4. public static void main(String[] args)
5. {
6. Scanner input = new Scanner(System.in);
7. int [] list; // declare list an array variable
8. list = new int[10]; //instantiate or create an array named list
9. System.out.print("Enter 10 integers: ");
10. // read values into list[0], list[1],..,list[9]
11. for (int i= 0; i < 10; i++)
12. list[i] = input.nextInt();
13. System.out.print("List in reverse : ");
14. //print values stored in list[9], list[8], … , list[0]
15. for (int i= 9; i >= 0; i--)
16. System.out.print(list[i] + " ");
17. System.out.println();
18. }
19. }
 Discussion

The program prompts for 10 integers. After the data is entered

(lines 11-12):

The array list holds 10 integers.

The individual memory cells are designated list[0], list[1], list[2], ... , list[8],
and list[9]
 Discussion

Line 7: int [] list;

• Line 7 is an array declaration as indicated by the square

brackets [].

• Like any variable, list must be declared before its use.

• The statement on line 7 declares that list is a reference

variable

• The declaration does not assign a value to list.

• No memory has been allocated yet; no array exists yet.

 Discussion

Line 8: list = new int[10];

• The segment new int[10] allocates a block of memory large

enough to store ten integers, and returns the starting
address of this memory chunk.

• The new operator creates or instantiates a new array.

• The operator reserves a consecutive block of storage

locations in memory, and returns the starting address of the
block. All are initialized to 0:
list
 Discussion

Lines 11 and 12: for (int i= 0; i < 10; i++) list[i] = input.nextInt();

• Lines 11 and 12 comprise a for loop­that accepts interactive input

and stores the values in list[0], list[1], list[2], list[3], list[4], list[5],
list[6], list[7], list[8], and list[9].
 Discussion

Lines 15 and 16: for (int i= 9; i >= 0; i--)

System.out.print(list[i] + " ");

The for loop prints the array items in reverse.: list[9], list[8],
…, and list[0].
 Array Initialization

• Java provides a convenient form of array initialization.

• The following code segment declares and explicitly initializes

an array of characters:

char letters[] = {'a', 'b', 'c'};

• The new operator is not explicitly used.

• This initialization of letters is equivalent to:

char letters[] ;
letters = new char[3];
letters[0] = 'a';
letters[1] = 'b';
letters[2] = 'c';
 Array Initialization

• Similarly:

int[] squares = {0,1,4,9,16,25,36,49,64,81,100};

is shorthand for:

int[] squares = new int[10];

for (int i= 0; i<11; i++ )
squares[i] = i*i;

• Explicit method of array initialization is convenient only when

the size of the array is not particularly large
 The = Operator

• The assignment operator (=) can be used with array references, but such
use can lead to some unexpected results and subtle bugs:

int [] a = {5,4,3,2,1};
int [] b = new int[5]; // initialized to 0’s
b = a;
a[0] = 100;
System.out.println(“ a[0] is ” + a[0]+ “ and b[0] is ” +b[0]);

• Output:

a[0] is 100 and b[0] is 100

• Both a[0] and b[0] are 100.

• a and b are both references, i.e., a and b each holds a single address.
 The = Operator

Int[] a = {5,4,3,2,1}
Int[] b = new int[5]
 The = Operator

b=a

After the assignment b=a

 The = Operator

B[0] = 100;

After executing the assignment b=a, the references a

and b both refer to the same memory and any
changes to a[i] affect b[i].
 The == Operator

• The == operator does not compare the contents of the arrays; the ==
operator compares references.

• int[] a = {5,4,3,2,1};
• int[] b = {5,4,3,2,1};
• int[] c = a;

• The expression a == b is false because a and b hold different references

• a == c evaluates to true.

Figure 7.13 Comparing array references

 Arrays and Methods

• An array reference can be passed as a parameter to a

method.

• When an array is passed to a method, only the reference or

address of the array is copied to the parameter of the
method.

• The values stored in the array are not passed or copied.

 Arrays and Methods

If an array reference x is passed as an argument to a parameter

data then both x and data refer to the same memory block:

public static void changeMe(int[] data)

{
data[0] = 200;
data[1] = 400;
}
public static void main(String [] arga)
{
int x[] = {2, 4, 6, 8};
changeMe(x);
System.out.print(“x now has values ”+ x[0]+ “ ”+x[1]+ “ ”+ x[2]+ “ ” + x[3]);
}
 Arrays and Methods

When x is passed as an argument to:

changeMe( int[] data)

the address that is stored in x is passed to data.

• data and x refer to the same block of memory;

• changeMe(...) assigns new values (200 and 400) to data[0] and data[1] and consequently
to x[0] and x[1]

• When the changeMe(...) returns, the final print(..) statement displays:

x now has values 200 400 6 8

Both argument x and parameter data refer to the same array.

 Arrays and Methods

Write a method:

void swap(int [] x, int i, int j)

that accepts three parameters:

• an array reference x
• two array indices i and j

and interchanges the contents of x[i] and x[j]:

public static void swap ( int[] x, int i, int j)

{
// swaps x[i] and x[j]
int temp = x[i];
x[i] = x[j];
x[j] = temp;
}

In main:
int [] a = { 1,3,5,7,9};
swap(a, 2,4) // swap a[2] and a[4]

Before: 1 3 5 7 9
After: 1 3 9 7 5
 Insertion Sort

An array of integers, partially sorted:

[2 3 5 9 4]

• The last element must be inserted into the sorted group at its correct position. To place
this number (4) into its proper position:
• Copy the value in the last position (4) to a temporary variable, temp, so that the value is “safe.” That is, the value is
put aside for safe keeping.

• Compare 4 to 9, the element in the last position of the sorted sub-array. Since 9 is larger, 4 precedes 9 in the
sorted array; so shift (copy) 9 one position to the right :

[2 3 5 9 4]  [2 3 5 9 9]. We did not “lose” the 4; it is stored in temp.

• Compare 4 to 5. Since 5 is the larger number, shift 5 one position to the right:

[2 3 5 9 9]  [2 3 5 5 9]

• Compare 4 to 3. Since 3 is less than 4, the correct position of 4 has been found. Now, place 4, which has been
saved in temp, in the position immediately following 3 and stop. The value 4 now sits in its correct place following 3
and preceding 5:

[2 3 5 5 9]  [2 3 4 5 9]
 Insertion Sort

Insert a number into its correct position within a sorted list

 Insertion Sort

This insertion process can be implemented as a void method

void insert(int[] x, int i)

that places the ith value of x into its proper position among the sorted values
x[0], x[1],…x[i-1], shifting numbers to the right if necessary.

The method operates as follows:

• copy x[i] into a temporary variable, temp.

• initialize a counter j to i-1, the largest index of the sorted sub-array.
• while (j >= 0 and temp < x[j] )
• copy x[j] to x[j+1] and decrement j // shift.
• copy temp to x[j+1].
 Putting the Insertion Method to Work

• To sort an array of n elements, insertion sort invokes the insert(...) method n – 1

times

• It incrementally builds sorted sub-arrays (x[0] x[1]), then (x[0] x[1] x[2]), then
(x[0] x[1] x[2] x[3])…and finally (x[0] x[1] x[2] x[3]…x[n-1]).

Insertion sort calls insert n-1 times

 Problem
Problem statement

Implement insertion sort.

 Solution

1. public static void insert ( int[] x, int i)

2. {
3. // place x[i] in its proper place among sorted values x[0],
x[1]…x[i-1]
4. int temp = x[i]; // save the value
5. int j = i-1;
6. while ( j >= 0 && temp <x[j]) //determine where to place temp
7. {
8. x[j+1] = x[j]; // shift right
9. j--;
10. }
11. x[j+1]= temp; //place temp (x[i]) in its correct position
12. }
13. public static void insertionsort(int[] x, int n)
14. { // n is the number of data stored in array x
15. for (int i = 1; i < n; i++)
16. insert(x,i);
17. }
 Discussion
• The array can be partially filled. The number of elements that
must be sorted is size, and not x.length.

• For a data set of size n, insertion sort performs at most ½(n2

– n) comparisons.

• On the other hand, if the data are already sorted, insertion

sort makes just n – 1 comparisons
 Linear Search

Begin with x[0] and successively compare key to each item in

the array:

• Does key == x[0]?

• Does key == x[1]?
• Does key == x[2]? etc.

• If key matches x[i] for some index i, the search terminates

and returns array index i, the index of the cell of the array
where key resides.

• If key is not found in the array, the search returns -1 or some

other value indicating a failure to locate key.
 Linear Search

1. public static int search(int[] x, int n, int key)

2. {
3. // returns the position of key in x
4. // if key is not found returns -1
5. // the array x may be partially filled; n is the number of data in x
6.
7. for ( int i = 0; i < n; i++)
8. if (key == x[i]) // key is found
9. return i; // return the index
10. return -1; // key is not found
11.
12. }
 Binary Search

• A search routine that performs much better than linear search is binary search.

• Binary search requires that the array be sorted.

• To search an array x, for key, binary search first compares key to the item
situated in the middle of the array, say x[mid].

• If key equals x[mid], the search ends successfully.

• If key < x[mid], then x[mid] and all elements greater than x[mid] are eliminated
from the search.

• If key > x[mid], then x[mid] and all items less than x[mid] can be eliminated.

• Thus after examining a single location, half of the data in the array can be
eliminated from the search.

• Binary search repeats this process on the part of the array that has not yet been
eliminated until the key is located or there are no more items to examine.
 Binary Search

• Search for the key 27 in the sorted array:

[3 5 6 9 11 23 25 26 27 29 33 35 36 37 39 42 45 46 48 58 62 67 70].

• Binary search first compares 27 to the middle item of the

array, which is 35.

• Because 27 is less than 35 and the array is sorted, the

“sub-array” [35 36 37 39 42 45 46 48 58 62 67 70] can be
eliminated from any further searching.

• If 27 is on the list, then 27 must be situated in the “sub-array”

[3 5 6 9 11 23 25 26 27 29 33].
 Binary Search

After one comparison , half the array is eliminated

Next, binary search compares the key (27) to the middle
element of this sub-array:
 Binary Search

Binary search after two comparisons

 Binary Search

Since 27 is greater than the middle element (23), binary search now
searches those values greater than 23.

The key is found

The key value 27 is located after examining just three locations.
 Binary Search

1. static int search(int[] x , int n, int key)

2. // x is a sorted array of n integers; key has an integer value
3. //x is sorted in ascending order;
4. {
5. int lo = 0; // lowest index of the array
6. int hi = n-1; // highest index
7. int mid; // middle index
8. while (hi >= lo)
9. {
10. mid = (hi + lo)/2; // get the middle index
11. if (key == x[mid])
12. return mid; //key found --exit
13. if (key < x[mid])
14. hi = mid - 1; //eliminate x[mid] thru x[hi]
15. else
16. lo = mid + 1; // eliminate x[lo] thru x[mid]
17. }
18. return -1; // key not found
19. }
 Binary search in action.
key = 27; blocks in gray are eliminated from the search

Iteration 1 Iteration 2 Iteration 3

lo = 0; hi = 22; mid = 11 lo = 0; hi = 10; mid = 5 lo= 6; hi = 10; mid = 8

Adjust hi : hi = mid-1 Adjust lo: lo = mid+ 1 Return 8 – index of

the key
.
 Binary Search

• For a list of n items, linear search, on average, examines n/2 locations.

• Binary search checks only about log2 n – 1 locations:

n n/2 (linear search) log2n –1 (binary search)

210 =1024 512 9

215 =32768 16384 14
220 =1048576 524288 19
225 =33554432 16777216 24
 Two-Dimensional Arrays

1% 2% 3% 4% 5% 6%
10 years 1.10 1.22 1.34 1.48 1.63 1.79
15 years 1.16 1.35 1.56 1.80 2.08 2.40
20 years 1.22 1.49 1.81 2.19 2.65 3.21
25 years 1.28 1.64 2.09 2.67 3.39 4.29
30 years 1.35 1.81 2.43 3.24 4.32 5.74

• A two-dimensional array holds tabular data:

• The values stored in a two-dimensional array must all be of the

same data type.

• Each storage cell in the table is uniquely identified by its row and
by its column. The rows and columns of a two-dimensional array
are indexed starting at 0.
Two-Dimensional Arrays

X is located in row 3, column 1

 Two-Dimensional Arrays

A 2 × 2 array, and a 3 × 2 array

Each cell in a two-dimensional array can be accessed using its row
and column number. The cell A[i][j] is the cell of row i and column
j. .
 Two-Dimensional Arrays

Each cell has can be accessed with two indices

 Declaring and Instantiating Two-
Dimensional Arrays
The statement:
int[][] table;
declares table to be a reference to a two-dimensional array of integers.

Two-dimensional instantiation includes the number of rows as well as the

number of columns, in that order:

table = new int[2][3]; // table has 2 rows and 3 columns

int[] table = new int[2][3];

 Two-Dimensional Arrays

• Declaration and instantiation can be done with a single

statement:

int [][] table = new int[2][3];

• The new operator creates a 2 × 3 two-dimensional array with

all cell values initialized to 0.
 Two-Dimensional Arrays

• Although it is intuitive to view a two-dimensional array as a

simple table, the underlying structure is more complex.

• A two-dimensional array is actually an “array of arrays.”

An array of arrays
It is easier to visualize a two-dimensional array as a simple table or grid

A two-dimensional array pictured as a table or grid

 Processing a Two-Dimensional Array

int A[][] = new int[3][4]; // declares and instantiates a 3 × 4 array

for (int row = 0; row < 3; row++) // for each row

for (int col = 0; col < 4; col++) // for each column
A[row] [col] = row*col;

The loops work as

follows:
row = 0 col = 0 A[0][0] = 0
col = 1 A[0][1] = 0
col = 2 A[0][2] = 0
col = 3 A[0][3] = 0
row = 1 col = 0 A[1][0] = 0
col = 1 A[1][1] = 1
col = 2 A[1][2] = 2
col = 3 A[1][3] = 3
row = 2 col = 0 A[2][0] = 0
col = 1 A[2][1] = 2
col = 2 A[2][2] = 4
col = 3 A[2][3] = 6

0 0 0 0
0 1 2 3
0 2 4 6

Array initialized with nested loops

 Processing a Two-Dimensional Array

• A two-dimensional array can be explicitly initialized in a

declaration by listing the values of each row enclosed by
curly braces and separated by commas:

int[][] table = { {2,4,6} {8,10,12} };

An array explicitly initialized in its declaration

 Processing a Two-Dimensional Array

Reading data into a two dimensional array:

Scanner input = new Scanner(System.in);

int [][] a = new int[5][4];
for (int row = 0; row < 5; row++)
for (int col= 0; col < 4; col++)
a[row][col] = input.nextInt();

Displaying the contents of a, row by row:

for ( int row = 0; row < 5; row++) // for each row

{
for (int col = 0; col < 4; col++) //for each column
System.out .print (a[row][col] + “ “); // print the column value
System.out.println(); // a newline for the next row
}

Java allows arrays of dimension higher than two. A three-dimensional array:

int[][][] threeD;
threeD new int[3][4][5];
for (int i = 0; i < 3; i++)
for (int j = 0; j < 4; j++)
for (int k = 0; k < 5; k++)
threeD[i][j][k] = i*j*k;
 Processing a Two-Dimensional Array

Example:

• A contingency table is a two-dimensional grid often used as an aid for analyzing the
relationship between two variables.

• For example, a researcher interested in whether or not a relationship exists between

gender and music preference surveyed 1000 people with the following results:

Rock Heavy Metal Folk Jazz R& B Pop Country Other Total
Males 123 145 33 34 16 71 18 42 482
Females 138 112 50 27 93 75 10 13 518
Total 261 257 83 61 109 146 28 55 1000
• The numbers in the last column and last row are not part of the collected data.

• These are the row totals and the column totals.

• The number in the bottom right corner is the grand total, the sum of all data.
 Processing a Two-Dimensional Array

Problem Statement:

• Write an application that queries a user for the number of rows and columns of a
contingency table, reads the data, row by row, and displays the data in tabular
form along with the row totals, column totals, and grand total.

For example, if the 6 data of a 2×3 table are:

1, 3, 6, 7, 9, and 8,

the program displays these 6 numbers together with the appropriate totals as:

1 3 6 | 10
7 9 8 | 24

8 12 14 | 34

10 and 24 are row totals, 8, 12, and 14 the column totals, and 34 the grand total.

• The “|” character is used to separate the data from the row totals.
 Processing a Two-Dimensional Array

The solution utilizes three methods:

• readData (...) fills a two-dimensional array with data supplied

by the user. The data is entered row by row.

• display(...) prints the table along with the row, column, and
grand totals.

• getTotals(...) calculates the row totals, and the column totals.

 readData

import java.util.*;

1. public class ContingencyTable

2. {
3. public static void readData( int[][] table, int numRows, int numCols)
4. {
5.
6. // reads the data for a table row by row
7. // the table has rows rows and cols columns
8.
9. System.out.println("Enter data, row by row: ");
10. Scanner input = new Scanner(System.in);
11. // read data , row by row
12. for (int row = 0; row < numRows; row++)
13. for (int col = 0; col < numCols; col++)
14. table[row][col] = input.nextInt();
15. }
 display

16. public static void display(int table[][], int numRows, int numCols,
int[] rowSums, int[] colSums)
17. {
18. // displays the contingency table
19. // displays row and column totals and grand total
20. System.out.println();
21. System.out.println();
22. System.out.println("Data including row and column totals: ");
23. System.out.println();
24. // print the table row by row
25. // after printing a row, print the row total
26. for(int row = 0; row < numRows; row++) // for each row
27. {
28. for (int col = 0; col < numCols; col++) // for each column
29. System.out.print(" "+table[row][col]+"\t");
30.
31. System.out.println("| "+rowSums[row]); // print the row total
32. }
 display

33. System.out.println();
34. int grandTotal = 0;
35. // calculate the grand total from the column sums
36. // print the column sums then the grand total
37. for (int col = 0; col < numCols; col++) // for each column
38. {
39. grandTotal += colSums[col]; //add column sum to grandTotal
40. System.out.print(" "+colSums[col]+"\t"); //print column sum
41. }
42. System.out.println("| "+grandTotal);
43. }
 getTotals

44. public static void getTotals(int[][]table, int numRows, int numCols,

45. int[] rowSums, int [] colSums)
46. {
47. //calculates the row sums and column sums
48. // get row sums
49. for (int row = 0; row < numRows; row++) // for each row
50. for (int col = 0; col< numCols; col++) // for each column
51. rowSums[row] += table[row][col]; // add the table entry to
// the row sum
52. // get column sums
53. for (int col = 0; col < numCols; col++) // for each column
54. for (int row = 0; row< numRows; row++) // for each
row
55. colSums[col] += table[row][col]; // add the table entry to
// the column sum
56. }
 main

57. public static void main(String[] args)

58. {
59. Scanner input = new Scanner(System.in);
60. int rows, cols; // dimensions of the table
61. int[][] table; // contingency table
62. int[] rowSums; // holds the row totals
63. int colSums[]; // holds the column totals
64. System.out.print("Number of rows: " );
65. rows = input.nextInt();
66. System.out.print("Number of columns: ");
67. cols= input.nextInt();
68. table = new int[rows][cols];
69. rowSums = new int[rows];
70. colSums = new int[cols];
71. readData(table, rows, cols);
72. getTotals(table, rows, cols, rowSums, colSums); // calculate the sums
73. display(table, rows, cols, rowSums,colSums);
74. }
75. }
 Output

Number of rows: 2
Number of columns: 8
Enter data, row by row:
123 145 33 34 16 71 18 42 138 112 50 27 93 75 10 13

Data including row and column totals:

123 145 33 34 16 71 18 42 | 482

138 112 50 27 93 75 10 13 | 518

261 257 83 61 109 146 28 55 | 1000

 Discussion

Lines 4 – 14: void readData( int[][] table, int numRows, int

numCols)

• The nested loop on lines 11-13 iterates through the table row by
row.

• If the table has 2 rows and 3 columns, the nested loop runs
through the indices of the array in the following order:

[0,0] [0,1] [0,2] // row = 0, col = 0,1,2

[1,0] [1,1] [1,2] // row = 1, col = 0,1,2
 Discussion

Lines 15 – 41: display (int table[][], int numRows, int

numCols, int[] rowSums, int[] colSums)

• The nested loop on lines 25-30 iterates through the table row
by row. Before incrementing the loop counter row the
method prints a separator character (‘|’) followed by the row
total. The data of each row is printed, followed by the
separator, followed by the row total. If the table consists of
two rows and three columns, printing proceeds:

[0,0] [0,1] [0,2] rowSum[0] // row = 0, col = 0,1,2

[1,0] [1,1] [1,2] rowSum[1] // row = 1, col = 0,1,2
 Discussion

• The single loop on lines 35-39, which iterates through the

columns:

• adds each column sum to the grand total ( line 37), and
• prints each column sum (line 38).

• The statement on line 40 prints the separator and the grand

total.
 Discussion

Lines 42 – 53: void getTotals(int[][]table, int numRows, int

numCols, int[] rowSums, int[] colSums)

• This method calculates values stored in the two one-

dimensional arrays, rowSums and colSums

• The nested loop on lines 46-48, iterates through the table,

row by row.

• For each row, the corresponding column value is added to

the row total.
If table is a 2×3 array, the calculation proceeds as follows:

Initially rowSum[0] and rowSum[1] have value 0

row = 0 col = 0 rowSum[0] += table[0][0]

col = 1 rowSum[0] += table[0][1]
col = 2 rowSum[0] += table[0][2]

row = 1 col = 0 rowSum[1] += table[1][0]

col = 1 rowSum[1] += table[1][1]
col = 2 rowSum[1] += table[1][2]
 Index out of Bounds

The infamous “array index out of bounds” error.

• An array x of length n is indexed from 0 to n-1.

• An attempt to access x[n] or x[x.length] results in a runtime error, that is,

one that occurs during the run of the program and terminates the
program.

• When using a for loop to process x, the correct form is:

for (int i = 0; i < x.length; i++)

and not

for (int i = 0; i <= x.length; i++)