You are here

Array Processing Using Loops

15 January, 2016 - 09:02
Available under Creative Commons-ShareAlike 4.0 International License. Download for free at

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; 11 initialize the sum 

for(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 beginning 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 sum 

for(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

        if(myArray[minIdx] > myArray[j])

            minIdx = j; // found new minimum



Some important things to notice about this algorithm:

  • The empty case must be checked explicitly no polymorphism to help you out here!
  • The desired result index cannot be declared inside the for loop because otherwise it won't be visible to the outside world.
  • Be careful about using the minIdx value if the array was indeed empty-it's an invalid value! It can't be set to a valid value because otherwise you can't tell the difference between a value that was never set and one that was.
  • The for loop has two initialization statements separated by a comma.
  • The loop does work correctly if the array only has one element, but only because the termination check is done before the loop body.
  • Notice that to prove that this algorithm works properly, one must make separate arguments about the empty case, the one element case and the n-element case. Contrast this to the much simpler list algorithm that only needs an empty and non-empty cases.

For convenience, Java 5.0 now offers a compact syntax used for traversing all the elements of an array or of anything that subclasses type Iterable (Source here):

MyType[] myArray; // array is initialized with data somewhere 

for(MyType x: myArray){     // code involving x, i.e. each element in the array } 

It is important to remember that this syntax is used when one wants to process every element in an array (or an Iterable object) independent of order of processing because Java does not guarantee a traversal order.

Let's look at an algorithm where we might not want to process the entire array:

// Find the first index of a given value in an array 

int idx = -1; // initialize the index to an invalid value. 

for(int j=0; j<myArray.length; j++) { //no initialization ; end index at length-1; 
                                      //increment index every time the loop is processed. if(desiredValue == myArray[j]) { // found match! idx = j; // save the index. break; // break out of the loop. } } 
Note: The only way you can tell if the desired value was actually found or not is if the value of idx is -1 or not. Thus the value of idx must be checked before it is ever used.
Note: The resultant idx variable cannot be used as the index inside the loop because one would not be able to tell if the desired value was found or not unless one also checked the length of the array. This is because if the desired value was never found, idx at the end of the loop would equal the length of the array, which is only an invalid value if you already know the length of the array.
Note: The break statement stops the loop right away and execution resumes at the point right after end of the loop.

There is a counterpart to break called continue that causes the loop to immediately progress to the beginning of the next iteration. It is used much more rarely than break, usually in situations where there are convoluted and deeply nested if-else statements.

Can you see that the price of the compact syntax of for loops is a clear understandability of the process?