arrays

arrays: intro

Suppose we want to write a program that deals with monthly rainfall in the New River Valley. One way would be to have twelve different double variables:
rainInMonth.infoAt0, rainInMonth.infoAt1, rainInMonth.infoAt2, … rainInMonth.infoAt11.

Clearly, declaring, initializing, and processing twelve different double variables is ugly. Hmmm, previously we took several related values and bundled them up into a single object (e.g. a Student's name, credithours, etc.). Can we do the same with several related doubles? Yes!, and it's a type which is already built in to Java: array of double.

An array is a table of values, indexed starting from 0. For example, our twelve doubles could be handled as one object:

double[] rain;    // Declare a variable: its type is *array*-of-double.

rain = new double[12];   // Initialize ("allocate") the array (but not the array's contents).

// We now have twelve variables:
// rain[0], rain[1], rain[2], ..., rain[11]
// which we must initialize ourselves:

rain[0] = 2.3;
rain[1] = 4.1;
rain[2] = 3.7;

At this point, let's look at a picture of our object: in code pad, type rain and code pad will show the answer is <object reference> (double[]); double-click on the small red object-reference to see the actual object. The array is, conceptually, an object with twelve fields, named 0, 1, 2, … 11. However, to get/set these fields we use square-brackets: rain[index].
(Btw, what other field do we see inside the array object?)

A String is conceptually very similar to an array-of-character. To look up individual elements of a String we said something like word.charAt(7); we want to say something like rain.infoAt(7), but instead we'll write rain[7]. (Also: Unlike strings, arrays let us get and set the info stored at a particular index.)

Keep looking at the object as we continue initializing the array contents:

rain[3] = 4.2;
rain[4] = 0.0;
rain[5] = 2.7;
rain[6] = 0.0;

You can see visually, that we really are setting those entries in the array (table). By the way, can you look at the table and tell which entries we've initialized, and which we haven't? Yes, Java initialized the values for us (to 0.0, in the case of double[]). However, other people looking at our code may not be sure whether we wanted entries to be 0.0 or if we forgot to initialize the values (and, in case of a bug, they should spend time tracing this down). Also, other languages might not always initialize arrays. It's better to follow the simple rule:

programming tip: Always initialize all the entries of your array.

two things to remember: With regular variables, we had two steps: declare, then initialize. With arrays, we now have three steps: declare, initialize (allocate) the array itself, then initialize the contents of the array.

Syntax

The Java name for the type array-of-double is double[].
(Remember, one uses type-names when declaring variables, declaring fields, declaring parameters, and declaring a return-type.) To construct an array ¹: new double[int]. To access the 7th item of the array rain: rain[7].
In general: array[index].

Looping over an array

In the code pad, we can continue on. Suppose we want to calculate the the average value. This sounds like a job for [what type of programming statment?] Yes! -- a loop.
What do we need to set up for every loop? Yes! An index-variable, and a so-far variable:

        int i = 0;
        double rainSoFar = 0.0;
        while (i <                                  ) {
            rainSoFar = rainSoFar + rain[i];
            i = i + 1;
        }

After running this, we can look at rainSoFar / rain.length.

We can put this exact same thing inside a method:

    /** Calculate the average value in a given double[].
     * @param data The array to find the average of.
     * @return the average value of double[].
     */
    static                    avg(                                        ) {
        int i = 0;
        double sumSoFar = 0.0;
        while (i <                                  ) {
            sumSoFar = sumSoFar + data[i];
            i = i + 1;
        }
        return                                                                   ;
    }

(See soln.)
The nice thing about putting this in its own method is that it now works for any array-of-doubles we ever make:

double[] scores = new double[2];
scores[0] = 92.5;
scores[1] = 98.0;

Looper.avg(scores)                  // Assuming the above static method is inside a class 'Looper'



double[] silly = new double[0];     // Not a very useful array at all.
                                    // Note: No contents need initializing, whew.

Looper.avg(silly);

¹ You might think the syntax would be new double[]( 12 ), since that follows Java's general rule of new TypeName( arg… ). However, array-constructors (just like getting and setting array-elements fields) have a slightly different syntax from the usual method-call syntax. Sigh. ↩

This page licensed CC-BY 4.0 Ian Barland
Page last generated Please mail any suggestions
(incl. typos, broken links)
to ibarlandradford.edu