Section 6.3 for-each Statements
In Listing 5.5.2 we used a while-statement to iterate over the elements of an ArrayList to access each Oval object and change its fill color. We now know that we could have done the job using a for-statement as well. In both cases we would declare, initialize, and update a loop counter. We also need to correctly write the condition that tests for continuation of the next iteration. The need to access all elements of a Collection is common, and so a special statement was introduced to make this easier and less prone to error by eliminating the counter variable altogether. The for-each statement, also known as the enhanced-for, will iterate over any Collection that supports it, without the need for a loop counter variable.
Subsection 6.3.1 Parts of a for-each
The for-each statement is simpler to construct than other statements used for iteration. See Figure 6.3.1. Note that there is no need for a loop counter at all in the for-each statement. The variable
elm will refer to each element in the collection in order, first to last, and be available in the code block of the executed for-each.
Let’s rewrite only the parts of the
recolor(…) method from Listing 5.5.2 that form the loop and element access to use the for-each statement instead of a while-statement. In the following, the original while- version is on the left and the updated for-each version in the right. It is pretty clear that the for-each version is more compact, with fewer moving parts.public static void recolor(…) {
Oval o;
int i = 0;
while ( i < ovals.size() ) {
o = ovals.get(i);
o.setFillColor(…);
i++;
}
}
public static void recolor(…) {
for (Oval o : ovals) {
o.setFillColor(…);
}
}
When reading a for-each, it is convenient to read the "
:"" as "in." We usually read the above example as "for each Oval o in ovals."Also note that the
break and continue statements work as expected in a for-each. If a break is encountered, the iteration terminates and execution picks up immediately after the for-each block. If a continue is encountered the code block execution terminates and control is returned to the for-each to see if there is another element in the Collection to be processed.Subsection 6.3.2 Iterating over HashSet and HashMap Collection Classes
Iterating over the elements of a HashSet works just like iterating over the elements of an ArrayList. The syntax is identical.
public static void printHashSet(HashSet<String> set) {
for (String item : set) {
System.out.println(item);
}
}
In Listing 5.5.7 from Subsection 5.5.6 we collected several duplicated
chars in a HashSet and printed the final size of the HashSet. In Listing 6.3.2 we rewrite this example and add a standard for-each statement at the end that prints the Character objects in the HashSet after all are added. Looking at the output that follows you can see that only the unique Character objects are contained in the HashSet.// Unique2.java
import java.util.HashSet;
public class Unique2 {
public static void main(String[] args) {
// Create a HashSet to hold Character objects
HashSet<Character> letters = new HashSet<>();
// Add letters as chars, automatically boxed
letters.add( 'D' );
letters.add( 'O' );
letters.add( 'G' );
letters.add( 'D' );
letters.add( 'I' );
letters.add( 'G' );
letters.add( 'G' );
letters.add( 'E' );
letters.add( 'R' );
// Print unique letters in HashSet
System.out.println("Unique letters");
// Iterate over all elements of the HashSet
for ( Character c : letters ) {
System.out.print( c ); // Print each character
}
System.out.println();
}
}
Unique2.javajavac Unique2.java java Unique2 Unique letters RDEGIO
In Subsection 5.5.7 we noted that the keys of a HashMap must be unique, and the
keySet() method of a HashMap returns a set. We can use what we know about iterating over the elements of a HashSet combined with what we know about getting the elements of a HashMap using its get(…) method with a key to access all elements of a HashMap. In short, we iterate over all keys, and then use the key to access each element of the HashMap. This looks like the following code snippet, where myMap is a HashMap with String keys.for (String key : myMap.keySet()) {
System.out.println( myMap.get(key) );
In Listing 5.5.9 from Subsection 5.5.7 we printed the complete order of all three Musketeers by accessing the elements of the HashMap, assuming we knew the key values. In Listing 6.3.3 below we provide an update to that section of the code with one that does a better job, by iterating over all the keys in the
order HashMap and printing the associated ArrayList for each key. This ensures that if "d’Artagnan" shows up for dinner unexpectedly, his order will be printed as well because we no longer must know the names of all people at dinner in order to print the order. Output from the updated method follows Listing 6.3.3.System.out.println("Athos:");
for (int i=0;
i<order.get("Athos").size();
i++) {
System.out.println(" "
+ order.get("Athos").get(i));
}
System.out.println("Porthos:");
for (int i=0;
i<order.get("Porthos").size();
i++) {
System.out.println(" "
+ order.get("Porthos").get(i));
}
System.out.println("Aramis:");
for (int i=0;
i<order.get("Aramis").size();
i++) {
System.out.println(" "
+ order.get("Aramis").get(i));
}
// Iterate over key set
for (String musketeer : order.keySet())
{ // Print key
System.out.print(musketeer + ": ");
// Print mapped value
System.out.println(order.get(musketeer));
}
javac Musketeers2.java java Musketeers2 Porthos: [Cheese fries, Tuna sandwich, Chocolate shake] Athos: [Cobb salad, Grape juice] Aramis: [Greek salad, Iced tea]
Subsection 6.3.3 Limitations of the for-each Statement
The for-each does have a few limitations to be aware of. The temporary variable assigned to Collection elements must be declared within the scope of the for-each. In other words, it must have block scope. Unlike the other iteration statements, you cannot declare the variable assigned to Collection elements up front and then use it in the for-each statement.
Another limitation of the for-each statement is that you cannot modify the Collection while the iteration is underway. For example, you cannot use a for-each to search for certain elements in a Collection and delete them when found. If you want to do this, you must use a form of iteration that makes use of an element index, and keep track of how element indexes change as the Collection is modified.
