Arrays and Array Processing

Arrays

An array is a named collection of contiguous storage locations holding data of the same type.
Arrays elements are referenced by position within a structure rather than by name.

One Dimensional Arrays

Declaring and creating an Array.

Array varaibles are specified by having a pair of [] after the data type or after the variable name. This declares a variable called "arr" that will hold a reference (memory location) of one or more integers.

int[] arr; (preferred by author)
or
int arr[];

to create the array of integers, you have to use the new operator with the number in []

int[] arr; // Declare a name for the array
arr = new int[15]; // Create the array itself, 15 integers in size

Combine two steps into one:

int[] arr = new int[15];

An array element is referred to its position within the array.
For an n-element array named arr, the elements are named arr[0], arr[1], arr[2], ...,arr[n-1].
Arrays are zero indexed, that is, the first element in the array is referenced as number zero.
Array syntax : arrayname [ subscript ] where arrayname is the array name and subscript is an integer giving the element’s relative position.
Subscripted array variables are used like other variables:

arr[0] = 5;
arr[5] = 10;
arr[2] = 3;
strings[0] = "who";
strings[1] = "what";
strings[2] = strings[3] = "where";

Loops can be used to initialize them:

for (int k = 0; k < arr.length;k++)  
    arr[k] = 42;

Valid References: suppose array "arr" has 15 elements (example below) and j is 5 and k is 7.

arr[4]      // Refers to 16
arr[j]      // Is arr[5] which refers to 20
arr[j + k]  // Is arr[5+7] which is arr[12] which refers to 45
arr[k % j]  // Is arr[7%5] which is arr[2] which refers to -1

Invalid References:

arr[5.0]       // 5.0 is a float and can't be an array subscript
arr['5']       // '5' is a character not an integer
arr["5"]       // "5" is a string not an integer
arr[-1]        // Arrays cannot have negative subscripts
arr[15]        // The last element of arr has subscript 14
arr[j*k]       // Since j*k equals 35

Arrays are (mostly) treated as objects:

Instantiated with the new operator.
Have instance variables (e.g., length).
Array variables are reference variables.
As a parameter, a reference to the array is passed rather than copies of the array’s elements.

Array terminology:

An empty array is contains zero variables.
The variables are called components.
The length of the array is the number of components it has, the length is referenced using the array name followed by ".length" e.g.

System.out.println("Array arr has "+arr.length+" elements"); // print out the length of arr

Each element of an array has the same type.
A one-dimensional array has components that are called the array’s elements. Their type is the array’s element type.
An array’s elements may be of any type, including primitive and reference types.

Creating an array of objects (e.g. String)

Declared and created similarly to ints however, ...

Creating a new array of objects does not also create the objects that are stored in the array.
They must be instantiated separately.

Example: Create an array of 5 strings("hello - 0", "hello - 1", ... "hello - 4")

String[] strarr;                    // Declare a name for the array
strarr = new String[5];             // Create the array itself
                                    // Assign strings to the array
for (int k = 0; k < strarr.length; k++)    // For each array element
    strarr[k] = new String("hello - " + k ); // Assign it a new string

Initializing Elements

Array elements are initialized to default values:
Integer and real types are initialized to 0.
Reference types (objects) are initialized to null.
Arrays can be assigned initial values when they are created:

examples:

int[] arr = { -2,8,-1,-3,16,20,25,16,16,8,18,19,45,21,-2 } ;
String[] strings = { "hello", "world", "goodbye", "love"};

When an array initialization expression is used, don’t use the keyword new to create the array.
This works well for relatively small arrays. Large arrays should either be computer or read in from datafiles or databases

Passing arrays as arguments to methods

Pass by Value: When a value of primitive type is passed to a method, a copy of the value is passed. Any changes to the copy, have no effect on the original value.
Pass by Reference: When a reference to an object (e.g., an array) is passed to a method, changes made to the object do persist beyond the method.

Example: Store the First 100 Squares

    int[] intArr = new int[100];   // Create an int array
    for (int k = 0; k < intArr.length; k++) // Initialize the array
          intArr[k] = (k+1)*(k+1);

    System.out.print("The first 100 squares are"); // Print heading

    for (int k = 0; k < intArr.length; k++)
    {      // Print the array
       if (k % 10 == 0)
           System.out.println(" ");        // 10 elements per row
       System.out.print( intArr[k] + " ");
    } // for

Program Output:

The first 100 squares are
1 4 9 16 25 36 49 64 81 100
121 144 169 196 225 256 289 324 361 400
441 484 529 576 625 676 729 784 841 900
961 1024 1089 1156 1225 1296 1369 1444 1521 1600
1681 1764 1849 1936 2025 2116 2209 2304 2401 2500
2601 2704 2809 2916 3025 3136 3249 3364 3481 3600
3721 3844 3969 4096 4225 4356 4489 4624 4761 4900
5041 5184 5329 5476 5625 5776 5929 6084 6241 6400
6561 6724 6889 7056 7225 7396 7569 7744 7921 8100
8281 8464 8649 8836 9025 9216 9409 9604 9801 10000

Array Algorithm : Sequential Search

Problem: Search an array for a key value. If the array is not sorted, we have to search sequentially. That is, we must start at the beginning of the array and check each element until we find the one we want.

     for (int k = 0; k < arr.length; k++)
{
         if (arr[k] == key)
             System.out.println(key+" found at position "+k+" in array arr");
}

Variation: Search an array for the largest value:

int largest = Integer.MIN_VALUE; // largest will find the largest number
for (int k = 0; k < arr.length; k++)
{
if (arr[k] > largest)
largest = arr[k];
}

Arrays Class

This is a handy class that supports functions for one dimensional arrays.
To use, import java.util.*;
Some userful functions:

sort (array) - sorts the specified array. works for arrays of primitive types, Strings, and wrapper classes (Double, Integer, etc).

sort(array, fromindex, toindex) - sorts the items in the array starting at the fromindex up to but not including the toindex.

fill(array, value) - fills the array with the specified value

fill(array, fromindex, toindex, value) - fills the array from fromindex up to but not including the toindex with the given value.

Example:

String[] names = {"Mary","Fred","Sally","Cindy"};

Arrays.sort(names); // sorts the entire array
Arrays.sort(names,0,2); // sorts just the first two entries
Arrays.fill(names,""); // fills the array with empty strings.

Chapter 7 Two Dimensional Arrays

Two-dimensional array: an array whose components are themselves arrays.
Example: Compiling daily rainfall data.

A one-dimensional array makes it hard to calculate average monthly rainfall:

double rainfall[] = new double[365];

A two-dimensional array is an array of arrays. The first is the 12 months, indexed from 0 to 11. Each month array is an array of 31

double rainfall[][] = new double[12][31];

Since arrays are zero indexed, accessing them can sometimes be confusing. In this example, to get the rainfall for July 1 we'd access rainfall[6][0].

Initializing Two Dimensional Arrays

Two dimensional arrays can be initialized using nested for loops :

      for (int month = 0; month < rain.length; month++)
      {
         for (int day = 0; day < rain[month].length; day++)
         {
          rain[month][day] = 0.0;
         }
      }

Two dimensional arrays can also be initialized at the time they are created:

e.g. this will create an array with three rows, each of which has a different number of elements. Elements are initialized from 1.0 to 9.0

double d[][] = {{1.0,2.0,3.0}, {4.0,5.0}, {6.0,7.0,8.0,9.0}};

1.0    2.0    3.0
4.0    5.0
6.0    7.0    8.0    9.0

note:

d.length will equal 3
d[0].length will equal 3
d[1].length will equal 2
d[2].length will equal 4
d[2][3] will equal 9
this array is a ragged array since each row does not have the same number of items.
Indexes are created from the outside in, left to right

Example: Calculate average rainfall

   double total = 0;
     for (int month = 0; month < rain.length; month++)
         for (int day = 0; day < rain[month].length; day++)
             total += rain[month][day];

     double average = total/365;

Note : rain[2].length would tell how many array elements (days) there are for march, rain.length would tell how many element months there are.
Challenges:

How would you fix this code to correctly calculate the average rainfall on a leap year?
Could you add a feature that would print out the total number of days in the year it rained?
Could you add a feature to print out the day and month and amount of the day with the most rain?