用 for/in 在 Java 5.0 中增强循环

public void testForLoop(PrintStream out) throws IOException {
List list = getList();  // initialize this list elsewhere

for (Iterator i = list.iterator(); i.hasNext(); ) {
Object listElement = i.next();
out.println(listElement.toString());

// Do something else with this list element
}
}

public void testForInLoop(PrintStream out) throws IOException {
List list = getList();  // initialize this list elsewhere

for (Object listElement : list) {
out.println(listElement.toString());

// Do something else with this list element
}
}

for（
声明：
表达式）

语句

for (Iterator<
E> #i = (
expression).iterator(); #i.hasNext(); ) {

declaration = #i.next();

statement
}

for (Iterator #i = (
expression).iterator(); #i.hasNext(); ) {

declaration = #i.next();

statement
}

int[] int_array = new int[4];
String[] args = new String[10];
float[] float_array = new float[20];

public void testArrayLooping(PrintStream out) throws IOException {
int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };

// Print the primes out using a for/in loop
for (int n : primes) {
out.println(n);
}
}

public void testObjectArrayLooping(PrintStream out) throws IOException {
List[] list_array = new List[3];

list_array[0] = getList();
list_array[1] = getList();
list_array[2] = getList();

for (List l : list_array) {
out.println(l.getClass().getName());
}
}

public void testObjectArrayLooping(PrintStream out) throws IOException {
List[] list_array = new List[3];

list_array[0] = getList();
list_array[1] = getList();
list_array[2] = getList();

for (List l : list_array) {

for (Object o : l) {
out.println(o);
}
}
}

package com.oreilly.tiger.ch07;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class ForInDemo {
public static void main(String[] args) {

// These are collections to iterate over below
List wordlist = new ArrayList();
Set wordset = new HashSet();

// Basic loop, iterating over the elements of an array
//   The body of the loop is executed once for each element of args[].
//   Each time through, one element is assigned to the variable word.
System.out.println("Assigning arguments to lists...");
for (String word : args) {
System.out.print(word + " ");
wordlist.add(word);
wordset.add(word);
}

System.out.println();

// Iterate through the elements of the List now
//   Since lists have an order, these words should appear as above
System.out.println("Printing words from wordlist " +
"(ordered, with duplicates)...");
for (Object word : wordlist) {
System.out.print((String)word + " ");
}

System.out.println();

// Do the same for the Set. The loop looks the same but by virtue
//   of using a Set, word order is lost, and duplicates are discarded.
System.out.println("Printing words from wordset " +
"(unordered, no duplicates)...");
for (Object word : wordset) {
System.out.print((String)word + " ");
}
}
}

run-ch07:
[echo] Running Chapter 7 examples from Java 5.0 Tiger: A Developer's Notebook
[echo] Running ForInDemo...
[java] Assigning arguments to lists...
[java] word1 word2 word3 word4 word1
[java] Printing words from wordList (ordered, with duplicates)...
[java] word1 word2 word3 word4 word1
[java] Printing words from wordset (unordered, no duplicates)...
[java] word4 word1 word3 word2

List
<String> wordlist = new ArrayList
<String>();
Set
<String> wordset = new HashSet
<String>();

for (String word : wordlist) {
System.out.print(word + " ");
}

package com.oreilly.tiger.ch07;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class ForInDemo {
public static void main(String[] args) {

// These are collections to iterate over below

List<String> wordlist = new ArrayList<String>();
Set<String> wordset = new HashSet<String>();

// Basic loop, iterating over the elements of an array
//   The body of the loop is executed once for each element of args[].
//   Each time through, one element is assigned to the variable word.
System.out.println("Assigning arguments to lists...");
for (String word : args) {
System.out.print(word + " ");
wordlist.add(word);
wordset.add(word);
}

System.out.println();

// Iterate through the elements of the List now
//   Since lists have an order, these words should appear as above
System.out.println("Printing words from wordlist " +
"(ordered, with duplicates)...");
for (
String word : wordlist) {
System.out.print((String)word + " ");
}

System.out.println();

// Do the same for the Set. The loop looks the same but by virtue
//   of using a Set, word order is lost, and duplicates are discarded.
System.out.println("Printing words from wordset " +
"(unordered, no duplicates)...");
for (
String word : wordset) {
System.out.print((String)word + " ");
}
}
}

package java.util;
public interface Iterator<E> {
public boolean hasNext();

public E next();

public void remove();
}

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

package com.oreilly.tiger.ch07;
import java.util.LinkedList;
import java.util.List;
public class GuitarManufacturerList extends LinkedList<String> {
public GuitarManufacturerList() {
super();
}
public boolean add(String manufacturer) {
if (manufacturer.indexOf("Guitars") == -1) {
return false;
} else {
super.add(manufacturer);
return true;
}
}
}

package com.oreilly.tiger.ch07;
import java.io.IOException;
import java.io.PrintStream;
public class CustomObjectTester {

/** A custom object that extends List */
private GuitarManufacturerList manufacturers;

public CustomObjectTester() {

this.manufacturers = new GuitarManufacturerList<String>();
}

public void testListExtension(PrintStream out) throws IOException {
// Add some items for good measure
manufacturers.add("Epiphone Guitars");
manufacturers.add("Gibson Guitars");

// Iterate with for/in

for (String manufacturer : manufacturers) {
out.println(manufacturer);
}
}

public static void main(String[] args) {
try {
CustomObjectTester tester = new CustomObjectTester();

tester.testListExtension(System.out);
} catch (Exception e) {
e.printStackTrace();
}
}
}

package com.oreilly.tiger.ch07;
import java.util.Iterator;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* This class allows line-by-line iteration through a text file.
*   The iterator's remove() method throws UnsupportedOperatorException.
*   The iterator wraps and rethrows IOExceptions as IllegalArgumentExceptions.
*/
public class TextFile implements Iterable<String> {
// Used by the TextFileIterator below
final String filename;

public TextFile(String filename) {
this.filename = filename;
}

// This is the one method of the Iterable interface
public Iterator<String> iterator() {
return new TextFileIterator();
}

// This non-static member class is the iterator implementation
class TextFileIterator implements Iterator<String> {

// The stream being read from
BufferedReader in;

// Return value of next call to next()
String nextline;

public TextFileIterator() {
// Open the file and read and remember the first line
//   Peek ahead like this for the benefit of hasNext()
try {
in = new BufferedReader(new FileReader(filename));
nextline = in.readLine();
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
}

// If the next line is non-null, then we have a next line
public boolean hasNext() {
return nextline != null;
}

// Return the next line, but first read the line that follows it
public String next() {
try {
String result = nextline;

// If we haven't reached EOF yet...
if (nextline != null) {
nextline = in.readLine();    // Read another line
if (nextline == null)
in.close();                // And close on EOF
}

// Return the line we read last time through
return result;

} catch (IOException e) {
throw new IllegalArgumentException(e);
}
}

// The file is read-only; we don't allow lines to be removed
public void remove() {
throw new UnsupportedOperationException();
}
}

public static void main(String[] args) {
String filename = "TextFile.java";
if (args.length > 0)
filename = args[0];

for (String line : new TextFile(filename))
System.out.println(line);
}
}

List<String> wordList = new LinkedList<String>();
for (int i=0; i<args.length; i++) {
wordList.add("word " + (i+1) + ": '" + args[i] + "'");
}

public void determineListPosition(PrintStream out, String[] args)
throws IOException {

List<String> wordList = new LinkedList<String>();

// Here, it's easy to find position
for (int i=0; i<args.length; i++) {
wordList.add("word " + (i+1) + ": '" + args[i] + "'");
}

// Here, it's
not possible to locate position

for (String word : wordList) {
out.println(word);
}
}

StringBuffer longList = new StringBuffer();
for (int i=0, len=wordList.size(); i < len; i++) {
if (i < (len-1)) {
longList.append(wordList.get(i))
.append(", ");
} else {
longList.append(wordList.get(i));
}
}
out.println(longList);

public void removeListItems(PrintStream out, String[] args)
throws IOException {

List<String> wordList = new LinkedList<String>();

// Assign some words
for (int i=0; i<args.length; i++) {
wordList.add("word " + (i+1) + ": " '" + args[i] + "'");
}

// Remove all words with "1" in them.
Impossible with for/in!
for (Iterator i = wordList.iterator(); i.hasNext(); ) {
String word = (String)i.next();
if (word.indexOf("1") != -1) {

i.remove();
}
}

// You can print the words using for/in
for (String word : wordList) {
out.println(word);
}
}