Arrays in Java

More information on arrays can be found in the Java Resources web site page on arrays

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 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:

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 the loop is processed. 
        if(myArray[minIdx] > myArray[j])
            minIdx = j; // found new minimum
    }
}

Some important things to notice about this algorithm:

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:

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.
	}
}

Notes:

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?

for([initialization statement]; [termination expr] ; [increment statement]) {

	[loop body]

}

{

	[initialization statement];

	while([termination expr]) {

		[loop body]

		[increment statement];

	}

}

// Find the index of the first occurance of desiredValue in myArray, using a while loop.
{
	idx = -1;  // initialize the final result
	int j = 0; // initialize the index

	while(j < myArray.length) {   // loop through the array
		if(desiredValue == myArray[j]) {   // check if found the value
			idx = j;  // save the index
			break;   // exit the loop.
		}
		
		j++;   // increment the index
	}
}

Stuff[] s_array = new Stuff[n];
// fill s_array with values

for(int i = 0; i < s_array.length; i++) {
	// do something with s_array[i]
}

Stuff[] s_array = new Stuff[n];
// fill s_array with values

for(Stuff s:s_array) {
	// do something with s
}

Arrays vs. Lists

In no particular order...