In Java, the index of an array starts at 0 and counts up to one less than the number of elements in the array. Counting loops can easily do that. The example program (above) does that, except for a blank or two.

The variable egArray refers to an array object that has been constructed using an initializer list.

It is annoying to count the elements in an array. Worse, when you write a program you may not know in advance how many elements are needed. Array objects are created as the program runs. Often, the length of the array depends on data, and different runs of the program may process data that require different lengths of arrays.

Here is a program that prompts the user for each element of an array and reads it in. The array is hard coded to be five elements long. After it is filled with data, the array is written to the monitor.

Usually a program would do something with the data (besides just print it out) after it was read in. This would usually involve more loops.

Notice that the two for statements are the same. This is very common. It would be nice to copy this program to a file and to run it. When you do this, change the length of the array (the 5) to some other value (say, 9) and note the effect.

Review: Recall that the scope of the identifier index declared in the for statement is limited to just the body of its loop. So in the program, there are two variables, each named index, and each limited in scope to the body of its own for.

The largest integer in a list of integers is the maximum value. The maximum may occur several times, but no other integer in the list is larger. Look at the following:

2, 9, 52, 23, -19, 23, 17, -45, 0

The integer 52 is the maximum. If you plot these integers on a number line the maximum is the last one on the right.

Similarly, the smallest integer in the list is the minimum. The minimum may occur several times. In the above list, the minimum is -45. The minimum is the last number on the left of the number line.

A systematic procedure used to compute something is called an algorithm. The procedure described in the answer is an algorithm for finding the maximum of a list. An algorithm is a description of how to do something. It is not tied to any particular language. For example, you (possibly) followed the above algorithm when you mentally examined the list. An algorithm can be implemented in any computer programming language. The example program shows the above algorithm.

The variable max plays the role of the largest integer seen so far. The program scans elements of the array starting at index 0 and going to the end.

The variable max should be initialized to a value that is guaranteed to be no larger than the maximum element of the array. A program should always work correctly, regardless of the quirks of the data. Don't make assumptions about what the data look like. (The initializer list is only for a convenience in this example. A typical program would get its data from the user or from a file.)

class MaxAlgorithm
{

  public static void main ( String[] args ) 
  {

    int[] array =  { -20, 19, 1, 5, -1, 27, 19, 5 } ;
    int   max;

    // initialize the current maximum
 
    max =  ;

    // scan the array
    for ( int index=0; index < array.length; index++ )
    {
     
        <more stuff goes here>


    }
      
    System.out.println("The maximum of this array is: " + max );

  }
}    

Question 8:
Fill in the blank so that max is initialized to a value that is guaranteed to be no larger than the maximum element of the array, no matter what values are in the initializer list.

Classic Bug (1): It is tempting to initialize max to something you think is much less than the maximum, like -999. However, in doing so you make a risky assumption about the data. Perhaps the array holds the national debt for each of the last ten years. All these values are negative, and -999 would easily exceed the true maximum.

Examine the program. Notice how max is initialized to the first element in the array (at index 0). This assumes that the array exists and that it has at least one element. For the present program this is a safe assumption (but might not be in other situations.)

The for loop is set up to look at every element in the array, starting with the first element in cell 0, to see if that element is larger than the current maximum.

It would be OK (and perhaps preferable) to start out index at 1 since index 0 was used to initialize max. But the program as written works fine (as soon as you fill in the blank).

class MaxAlgorithm
{

  public static void main ( String[] args ) 
  {

    int[] array =  { -20, 19, 1, 5, -1, 27, 19, 5 } ;
    int   max;

    // initialize the current maximum
 
    max = array[0];

    // scan the array
    for ( int index=0; index < array.length; index++ )
    {
     
      if (  )  // examine the current element

        max = array[ index ];        // if it is the largest so far, change max

    }
      
    System.out.println("The maximum of this array is: " + max );

  }
}   

Question 9:
Complete the program.

class MaxAlgorithm
{

  public static void main ( String[] args ) 
  {

    int[] array =  { -20, 19, 1, 5, -1, 27, 19, 5 } ;
    int   max;

    // initialize the current maximum
    max = array[0];

    // scan the array
    for ( int index=0; index < array.length; index++ )
    { 
      if ( array[ index ] > max )    // examine the current element
        max = array[ index ];        // if it is the largest so far, change max

    }
      
    System.out.println("The maximum of this array is: " + max );
  }
}      

Question 10:
What is the maximum of this list of integers:
-45,  -23,  -87,  -56,  -92,  -12,  -36

Classic Bug (2): It is tempting to say that the maximum is -92, since -92 seems to be a bigger number than -12. But this confuses the absolute value of a number with its position on the number line. If you are looking for the maximum of a list of numbers, you are looking for the number which is furthest to the right on the number line, even if the number is negative.

Think of this as pay. If Jill is paid -92 dollars a day and Joe is paid -12 dollars a day, who is paid the most? (And exactly which fast food restaurant do they work at?)

The minimum of a list of numbers is the one furthest to the left on the number line.

Question 11:
What is the minimum of our list of integers:
-45,  -23,  -87,  -56,  -92,  -12,  -36

The change to the program introduces an off-by-one error. The array index does not go far enough to test the last cell of the array.

With a ten-element initializer list, the above buggy program will fail about one time in ten (assuming random lists of data). Failure might not be obvious, because the answer it computes is close to the maximum. With a ten thousand element array, the program will fail about one time in ten thousand! Sloppy testing will never find this bug. Off-by-one errors can be very subtle.

Classic Bug (3): Not testing the "boundaries". Bugs are often found at the boundaries: at the beginning and ends of loops, at the beginning and ends of data, with large or small values (or zero), with a very large amount of data, or with no data at all (which should not break the program).

Say that you want to compute the sum of a list of numbers. This algorithm sounds much like those of the previous two programs.

The sum is initialized to zero. Then the loop adds each element of the array to the sum.

You could initialize the sum to the first number and then have the loop add the remaining numbers. But there is no advantage in doing this.

Here is the program. The array contains values of type double. Assume that the array contains at least one element.

The variable total is declared to be of type double because the elements in the array are doubles, as is their sum. total is initialized to zero. Sums should always be initialized to zero.

(You could, perhaps, initialize total to the first element of the array, and then use the loop to add in the remaining elements. But this is much less clear than the expected way of doing things and is an open invitation to bugs.)

The program visits each element of the array, in order, adding each to the total. When the loop exits, total will be correct. The statement

would not usually be used. It is more common to use the += operator:

Are the following two arrays equal?

Obviously not.

Are these two arrays equal?

Less obvious, but ordinarily they would not be regarded as equal.

What about these two arrays: are they equal?

Here, it depends on what you mean by "equal". The object referred to by the variable arrayE is not the same object that is referred to by the variable arrayE. The "alias detector" == returns false.