X

Using Enhanced For-Loops with Your Classes

Guest Author

The author of this tip is John Zukowski, president and principal
consultant of JZ Ventures, Inc.

The enhanced for-loop is a popular feature introduced with the Java SE
platform in version 5.0. Its simple structure allows one to
simplify code by presenting for-loops that visit each element of
an array/collection without explicitly expressing how one goes from
element to element.


Because the old style of coding didn't become
invalid with the new for-loop syntax, you don't have to use an
enhanced for-loop when visiting each element of an
array/collection. However, with the new style, one's code would
typically change from something like the following:

for (int i=0; i < array.length; i++) {
System.out.println("Element: " + array[i]);
}

to the newer form

for (String element : array) {
System.out.println("Element: " + element);
}

Assuming "array" is defined to be an array of String objects,
each element is assigned to the element variable as it loops
through the array. These basics of the enhanced for-loop were covered
in an earlier Tech Tip: The Enhanced For Loop, from May 5, 2005.

If you have a class called Colony which contains a group of Penguin
objects, without doing anything extra to get the enhanced for-loop to
work, one way you would loop through each penguin element would be to
return an Iterator and iterate through the colony. Unfortunately, the
enhanced for-loop does not work with Iterator, so the following won't even compile:

// Does not compile
import java.util.\*;
public class BadColony {
static class Penguin {
String name;
Penguin(String name) {
this.name = name;
}
public String toString() {
return "Penguin{" + name + "}";
}
}
Set<Penguin> set = new HashSet<Penguin>();
public void addPenguin(Penguin p) {
set.add(p);
}
public Iterator<Penguin> getPenguins() {
return set.iterator();
}
public static void main(String args[]) {
Colony colony = new Colony();
Penguin opus = new Penguin("Opus");
Penguin chilly = new Penguin("Chilly Willy");
Penguin mumble = new Penguin("Mumble");
Penguin emperor = new Penguin("Emperor");
colony.addPenguin(opus);
colony.addPenguin(chilly);
colony.addPenguin(mumble);
colony.addPenguin(emperor);
Iterator<Penguin> it = colony.getPenguins();
// The bad line of code:
for (Penguin p : it) {
System.out.println(p);
}
}
}

You cannot just pass an Iterator into the enhanced for-loop. The 2nd
line of the following will generate a compilation error:

    Iterator<Penguin> it = colony.getPenguins();
for (Penguin p : it) {

The error:

BadColony.java:36: foreach not applicable to expression type
for (Penguin p : it) {
\^
1 error

In order to be able to use your class with an enhanced for-loop, it
does need an Iterator, but that Iterator must be provided via the
Iterable interface:

public interface java.lang.Iterable {
public java.util.Iterator iterator();
}


Actually, to be more correct, you can use a generic T,
allowing the enhanced for-loop to avoid casting, returning the
designated generic type, instead of just a plain old Object.

public interface java.lang.Iterable<T> {
public java.util.Iterator<T> iterator();
}


It is this Iterable object which is then provided to the enhanced for
loop. By making the Colony class implement Iterable, and having
its new iterator() method return the Iterator that getPenguins()
provides, you'll be able to loop through the penguins in the
colony via an enhanced for-loop.

By adding the proper implements clause:

public class Colony implements Iterable<Colony.Penguin> {

You then get your enhanced for-loop for the colony:

    for (Penguin p : colony) {

Here's the updated Colony class with the corrected code:

import java.util.\*;
public class Colony implements Iterable<Colony.Penguin> {
static class Penguin {
String name;
Penguin(String name) {
this.name = name;
}
public String toString() {
return "Penguin{" + name + "}";
}
}
Set<Penguin> set = new HashSet<Penguin>();
public void addPenguin(Penguin p) {
set.add(p);
}
public Iterator<Penguin> getPenguins() {
return set.iterator();
}
public Iterator<Penguin> iterator() {
return getPenguins();
}
public static void main(String args[]) {
Colony colony = new Colony();
Penguin opus = new Penguin("Opus");
Penguin chilly = new Penguin("Chilly Willy");
Penguin mumble = new Penguin("Mumble");
Penguin emperor = new Penguin("Emperor");
colony.addPenguin(opus);
colony.addPenguin(chilly);
colony.addPenguin(mumble);
colony.addPenguin(emperor);
for (Penguin p : colony) {
System.out.println(p);
}
}
}

Running the code produces the following output:

> java Colony
Penguin{Chilly Willy}
Penguin{Mumble}
Penguin{Opus}
Penguin{Emperor}

Keep in mind that the individual penguins are internally kept in a Set
type collection so the returned order doesn't necessarily match the
insertion order, which in this case it doesn't.

Remember to genericize the implements clause for the class "implements
Iterable<T>
" and not just say "implements Iterable". With the latter,
the enhanced for-loop will only return an Object for each element.

For more information on the enhanced for-loop, please see the
Java Programming Language guide from JDK 1.5

Join the discussion

Comments ( 2 )
  • LDN Friday, October 12, 2007

    Nice tutorial.


  • cyberbla Friday, October 26, 2007

    very good job thank you!

    but could u plz post a noob proof example...

    thx


Please enter your name.Please provide a valid email address.Please enter a comment.CAPTCHA challenge response provided was incorrect. Please try again.Captcha