Lesson 8.2 Processing Arrays

Processing Array Elements

To access an individual array element, you use the name of the array and add the subscript of the element you want to access in brackets following the name. Using this "compound" name, you can store new values in individual elements, or retrieve values from individual elements in the array. 

Storing and Retrieving Values

In the same way, you can retrieve a value simply by using the subscripted variable name in an expression, like this:

As you can see, when you use the subscripted name, the subscript (index) does not have to be a constant. You can use a variable or an expression as long as the result is an int value.

Although the type of the variable gradeAR is char[] (array of char), the type of the individual elements (gradeAR[0]) is plain-old char. You can treat each of the individual elements just as if it were a simple char variable. 

Back to Top

Errors

you'll get a compiler error because you can't store a double value in a char variable.

A more common mistake is to create a runtime error by trying to store values [or retrieve values] from an element outside the bounds of the array. The most common cause of this error is forgetting that a five-element array, like gradeAR, has subscripts that range from zero to four. The expression 

will throw an ArrayIndexOutOfBounds exception. This exception is an unchecked exception, so you don't have to place all of your array processing inside a try-catch block. You may, however, use try-catch to intercept this exception.

Back to Top

The length Field

• In an array, length is a field; in a String, length() is a method. It's easy to get the two of these confused.



String s = "Abara"; int lenS = s.length(); int lenA = gradeAR.length;

• The length field stores the number of elements in the array, not the highest subscript number, which is always length-1.
   

  gradeAR[length] = 'C';   // NO gradeAR[length-1] = 'C'; // OK

Using a Loop

Here are a few examples of common loops and the situation where you'll use them.

Initializing an Array

Here's an example that fills an array with random numbers:

Initializing a Random Array

// randAR is a double array int len = randAR.length; for (int idx = 0; idx < len; idx++) {   randAR[idx] = Math.random() * len; }

Back to Top

Summing and Averaging

Summing, averaging, and counting are all common operations performed on arrays. Here's a loop you can use as an example when you have to perform these operations:

Arrays and Methods

Let's see how that works.

Passing Array Variables

Suppose that you write a method that sums the values in a double array [of any size], and returns the result as a double. Using the method, you can calculate the sum of the elements in the double array nums like this:

When you write the method, the formal argument can't be a double; it must be an array of double. You write the method header like this:

or like this:

Here's the entire method.

Passing an Array Variable to a Method

double sumAR(double[] ar) {   double sum = 0.0;   for (int i = 0; i < ar.length; i++)   {     sum += ar[i];   }   return sum; }

Notice that you can pass any size array to this method because it uses the array's length field as the loop bounds.

Back to Top

Modifying an Array

When the array variable nums is passed to the method sumAR(), a copy of nums is made, as you can see in this figure.

 
[click the figure to enlarge]

This is the same as with any variable. All method arguments are passed by value in Java--a copy of the actual argument is made for use inside the method.

However, with an array, the effect might not be what you expect. Because both nums and ar refer to the same actual array, any changes made to the elements of the array ar inside the method sumAR() affect the elements of the array nums as well. To reiterate, both nums and ar refer to the same actual array.

Here's a method that shows you how that works. The method doubleAR() doubles every element in the array passed to it:

Back to Top

Array Copies

Occasionally, though, you have to pass an array to a method that changes the original array, but you still need to preserve the original array contents as well. 

This is not hard to do, but you have to know how to do it. You can't use the assignment operator like this:

If you do this, instead of having two array variables referring to the same actual array [ar and nums], you now have three: ar, nums, and copy. Any changes made to the elements of ar in the method doubleAR(), affect both copy and nums as well.

Since the assignment method obviously doesn't work, how do you do this correctly? There are two ways:

1. Write a loop and copy each element one-by-one.
2. Use the System.arraycopy() method.

Back to Top

System.arraycopy()

Unfortunately, a first look at its documentation can be daunting. System.arraycopy() takes five arguments:

1. The name of the source array [copy from here]
2. The offset to copy from [use 0 to start at the beginning]
3. The name of the destination [copy to here]
4. The offset to copy to [use 0 to start at the beginning]
5. The number of elements to copy

The JVM will throw an exception if any of these arguments are wrong. Fortunately, when copying an entire array, it's not hard to get them right. Simply do this:

That wasn't too hard, was it? We can make it easier though. How would you like to simply write this?

It's easy if you know how to write methods that return array variables.

Back to Top

Returning Array Variables

Suppose, for instance, you wanted to write a method that returned an array of random integers. Your method header would look like this:

Notice that the return type is declared as int[] and not int.

Once you've figured out how to write the return type, the next question that arises is "How do you get the array variable to return?" 

The answer is simple--you create a local array variable inside your method, and then return the local variable.

Here's the rest of the makeRandom() method that shows you how:

Returning an Array Variable from a Method

int[] makeRandom(int howMany) {   // 1. A random number generator   Random rand = new Random();   // 2. A local array variable   int[] ar = new int[ howMany ];   // 3. Fill it with random numbers   for(int i = 0; i < ar.length; i++)       ar[i] = rand.nextInt();   // 4. Return a copy of the local ar   return ar; }

If the "light has gone on", you probably now realize how you could "wrap up" a call to System.arraycopy() in a dupeAR() method, to make copying entire arrays a whole lot easier. 

The dupeAR() method would look like this:

A Note to C/C++ Programmers

If you've ever programmed in C or C++, returning a local array variable probably makes you a little woozy! Much of a C/C++ course is spent teaching you to avoid doing this at all possible costs.  In C/C++, if you return a local array from a function, the local array is "gone" by the time the function returns. In Java, however, all you are returning is a variable that refers to the array. The actual array is "out there" somewhere.  Of course, you could do the same thing in C/C++ by creating an array on the heap and then returning a pointer to it, but then you risk a memory leak. Because Java has automatic memory management, that's not an issue here.

Something to Talk About

Please continue to the next section of this lesson.

Back to Top