Using Foreach Loops in J2SE 1.5

Like many Java developers you are probably working with the beta for J2SE 1.5. Here is another new technique to use with the beta. Looping through a collection of objects and doing something with each object is one of the most common programming idioms. You've no doubt coded such a loop
many times:

Instead of using a for loop, you might have used a
while loop. You might have used an Enumeration, instead of an
Iterator, if you were working with the older Vector class. Or, you might have
used a for loop and a counter, accessing each element using the
get(int index) method of the List interface.

If you were to use an array, this is how you would typically iterate through
each of its elements:

It's not difficult to iterate through a collection, but it is a very
repetitive operation. Iteration requires you to type a good amount of
characters. Granted, the template feature of most IDEs will eliminate your need
to type so much. But, as you saw, there are many ways to iterate through a loop.

The existence of several different iteration techniques costs you more time.
For each iteration you encounter, you must spend a few extra seconds digesting
the iteration form. If it deviates from the form you're used to seeing, you must
examine it even closer. Why did the developer choose to code the iteration
differently?

It's also easy to make a mistake in coding your iterator. Ever accidentally
coded something like this?

I have. In a small section of code, it's easy to spot the error. In a
larger section of code, it's not as easy to spot.

The foreach Loop

Java 1.5 introduces a new way of iterating over a collection of objects. The
foreach loop is also known as the enhanced for loop. It is a new syntactical
construct designed to simplify iteration. The foreach loop should make iteration
more consistent, but only if and when everyone starts using it.

Effective use of the foreach loop depends on using Java 1.5's parameterized
types, also known as generics. So that you can understand the code in this
article, I'll explain how to use parameterized types.

Here is how you might construct and iterate a list of names in Java 1.5:

There are two important things in this bit of code: first, the use of a
generic list, and second, the use of the new foreach loop.

To construct an object of the parameterized ArrayList type, you bind
the ArrayList to a class. In the example, you bind the ArrayList to the String
class. You also bind the List reference to the String class. You are now
restricted to adding only String objects to the list. If you insert, for
example, a Date object in the names collection, your code will not
compile. When you retrieve objects from the list, you need not cast. Java knows
that the list contains only String objects. It does the casting for you, behind
the scenes.

Once you have stored objects in a parameterized List, you can iterate through
them using the foreach loop:

for (String name: names)

You read this statement as, "for each String name in names." The Java VM
executes the body of the foreach loop once for each object in the
names collection. Each time through the loop, Java assigns the next
object in turn to a local reference variable called name. You must
declare this reference variable as a String type--the type to which you bound
the names collection.

The foreach loop is succinct. There is no need to cast; Java does the cast
for you. You can use the name reference within the body of the loop
as a String reference. You cannot use the name reference outside
the body of the foreach loop.

Using Foreach with Arrays

You saw how the foreach loop allows you to iterate over collection class
types. Sun also modified Java to allow you to iterate through arrays using
foreach. The syntax is exactly the same: