9.3. Simple Array ExamplesThe program in Figure 9.5 creates two arrays of ten elements each and displays their values on the Java console. In this example, the elements of intArr have not been given initial values, whereas the elements of realArr have been initialized. Note the use of the integer constant ARRSIZE to store the arrays' size. By using the constant in this way, we do not have to use the literal value 10 anywhere in the program, thereby making it easier to read and modify the program. If we want to change the size of the array the program handles, we can just change the value of ARRSIZE. This is an example of the maintainability principle.
Maintainability principle Figure 9.5. A program that displays two arrays. Its output is shown in Figure 9.6.
Effective Design: Symbolic Constants
Note the use of the static qualifier throughout the PrintArrays class. This enables us to refer to the array and the other variables from within the main() method. If intArr were not declared static, we would get the compiler error attempt to make static use of a non-static variable. This use of static is justified mainly as a coding convenience rather than as a principle of object-oriented design. The only examples we have seen so far in which static elements were a necessary design element were the use of static elements in the Math classMath.PI and Math.sqrt()and the use of static final variables in TwoPlayerGameTwoPlayerGame.PLAYER_ONE. It is not always feasible to initialize large arrays in an initializer statement. Consider the problem of initializing an array with the squares of the first 100 integers. Not only would setting these values in an initializer statement be tedious, it would also be error prone, since it is relatively easy to type in the wrong value for one or more of the squares. Debugging Tip: Array Initialization
The example in Figure 9.7 creates an array of 50 integers and then fills the elements with the values 1, 4, 9, 16, and so on. It then prints the entire array. Figure 9.7. A program with an array that stores the squares of the first 50 integers. Its output is shown in Figure 9.8.
Figure 9.8. Output of the Squares program.
This example illustrates some important points about the use of array variables. The array's elements are individual storage locations. In this example, intArr has 50 storage locations. Storing a value in one of these variables is done by an assignment statement: intArr[k] = (k+1) * (k+1); The use of the variable k in this assignment statement allows us to vary the location that is assigned on each iteration of the for loop. Note that in this example, k occurs as the array index on the left-hand side of the expression, while k +1 occurs on the right-hand side as the value to be squared. The reason for this is that arrays are indexed starting at 0 but we want our table of squares to begin with the square of 1. So the square of some number n + 1 will always be stored in the array whose index is 1 less than the number itselfthat is, n.
Zero vs. unit indexing An array's length variable can always be used as a loop bound when iterating through all elements of the array: for (int k = 0; k < intArr.length; k++) intArr[k] = (k+1) * (k+1); However, it is important to note that the last element in the array is always at location length-1. Attempting to refer to intArr[length] would cause an IndexOutOfBounds-Exception because no such element exists.
Off-by-one error Debugging Tip: Off-by-One Error
Self-Study Exercise
|