This page is optimized for mobile devices, if you would prefer the desktop version just click here

4.4 Arrays and array processing (Page 2/4)

Array accesses

Indices for arrays must be int values that are greater than or equal to 0 and less than the length of the array. Remember that computer scientists always count starting at zero, not one!
All array accesses are checked at run time: An attempt to use an index that is less than zero or greater than or equal to the length of the array causes an IndexOutOfBoundsException to be thrown.
Array elements can be used on either side of an equals sign:
- myArray[i] = aValue;
- someValue = myArray[j];
Accessing elements of an array is fast and the time to access any element is independent of where it is in the array.
Inserting elements into an array is very slow because all the other elements following the insertion point have to be moved to make room, if that is even possible.

Array processing using loops

More information on loops can be found at the Java Resources web site page on loops .

The main technique used to process arrays is the for loop . A for loop is a way of processing each element of the array in a sequential manner.

Here is a typical for loop:

// Sum the number of elements in an array of ints, myArray.
int sum = 0;  // initialize the sumfor(int idx=0; idx<myArray.length; idx++) {  //start idx @ 0; end idx at length-1;
                                               //increment idx every time the loop is processed.sum += myArray[idx];  // add the idx'th element of myArray to the sum}

There are a number of things going on in the above for loop:

Before the loop starts , the index idx is being declared and initialized to zero. idx is visible only within the for loop body (between the curly braces).
At the begnning of each loop iteration , the index idx is being tested in a "termination condition", in this case, idx is compared to the length of the list. If the termination condition evaluates to false , the loop will immediately terminate.
During each loop iteration , the value of the idx 's element in the array is being added to the running sum.
After each loop iteration , the index idx is being incremented.

One can traverse an array in any direction one wishes:

// Sum the number of elements in an array of ints, myArray.
int sum = 0; // initialize the sumfor(int idx=myArray.length-1; 0<=idx; idx--) { //start idx @ length-1; end idx at 0;
                                               //decrement idx every time the loop is processed.sum += myArray[idx]; // add the idx'th element of myArray to the sum}

The above loop sums the list just as well as the first example, but it does it from back to front. Note however, that we had to be a little careful on how we initialized the index and how we set up the termination condition.

Here's a little more complicated loop:

// Find the index of the smallest element in an array of ints, myArray.
int minIdx = 0; // initialize the index. Must be declared outside the loop.if(0==myArray.length) throw new NoSuchElementException("Empty array!"); //No good if array 
                                                                        //is empty!else {
    for(minIdx = 0, int j = 1; j<myArray.length; j++) { //start minIdx @ 0, start index @ 1;
                                                           //end index at length-1; increment// index every time the loop is 
                                                           //processed.if(myArray[minIdx]>myArray[j])minIdx = j; // found new minimum
    }}

<< Chapter < Page Page > Chapter >>

Read also:

OpenStax, Principles of object-oriented programming. OpenStax CNX. May 10, 2013 Download for free at http://legacy.cnx.org/content/col10213/1.37

Google Play and the Google Play logo are trademarks of Google Inc.