Java iterators examples.

Examples of for-each loops on Iterable objects and behind-the-scenes of a for-each loop.


import java.util.ArrayList;
import java.util.Iterator;
import java.util.Stack;


public class IterableExamples {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		/********** Examples of for-each loop *********/
		/*** Any object that implements Iterable<E> can be 
		 used in a for-each loop with the element type E ****/
		
		ArrayList<Integer> numbers = new ArrayList<Integer>();
		
		//initialize the array list to integers 0 to 9
		for (int i = 0; i < 10; ++i){
			numbers.add(i);
		}
		
		// printing the ArrayList in a for-each loop
		System.out.println("The array list:");		
		for (Integer element: numbers) {
			System.out.print(element + " ");
		}
		System.out.println(); // print new line
		
		// adding all array list elements in a for-each loop:
		int sum = 0;
		for (Integer element: numbers) {
			sum += element;
		}	
		System.out.println("The sum of all elements is " + sum);
		
		Stack<Integer> numStack = new Stack<Integer>();
		
		// pushing all elements of the array list onto the stack
		for (Integer element: numbers) {
			numStack.push(element);
		}
		
		// printing the stack in a for-each loop:
		System.out.println("The stack:");		
		for (Integer element: numStack) {
			System.out.print(element + " ");
		}	
		System.out.println(); // print new line
		
		// Behind the scenes of a for-each loop.
		// This loop is equivalent to the sum loop above
		sum = 0;
		Iterator<Integer> theIterator = numbers.iterator();
		while (theIterator.hasNext()) {
			sum = sum + theIterator.next();
		}
		System.out.println("The sum of all elements is " + sum);
		
	}

}

A somewhat artificial example: making a string iterable.


/**
A string that can be iterated character by character
in a for-each loop
**/

import java.util.Iterator;
import java.util.NoSuchElementException;

public class IterableString implements Iterable<Character> {
	private String thestring;

	/**
	 * Creates a new IterableString
	 * 
	 * @param string
	 *            -- the string data
	 **/
	public IterableString(String string) {
		thestring = string;
	}

	/**
	 * Returns an iterator for the string that iterates character by character
	 **/
	public Iterator<Character> iterator() {
		return new StringIterator();
	}

	// the iterator is a private inner class
	private class StringIterator implements Iterator<Character> {
		private int position = 0;

		/**
		 * @return - true if there are more characters in the string, false
		 *         otherwise
		 **/
		public boolean hasNext() {
			return position < thestring.length();
		}

		/**
		 * @return - the next characters in the string
		 * @throws NoSuchElementException
		 *             when past the last character
		 **/
		public Character next() {
			if (position < thestring.length()) {
				Character current = thestring.charAt(position);
				++position;
				return current;
			} else {
				throw new NoSuchElementException();
			}
		}

		/**
		 * method not supported
		 **/
		public void remove() {
			throw new UnsupportedOperationException();
		}
	}
}

Another example: Fibonacci iterator.


/**
 The class implements Iterable Fibonacci numbers, i.e. 
 Fibonacci numbers that can be produced in a for-each
 (enhanced for) loop. 

 Fibonacci numbers are a sequence of numbers defined as 
 follows:
 F(0) = 0, F(1) = 1, F(k) = F(k-1) + F(k -2) for k > 1.

 For more on Fibonacci numbers see
 http://en.wikipedia.org/wiki/Fibonacci_number

 The parameter maxIndex in the constructor sets the 
 last index in the sequence. It can be reset using
 setMaxIndex method. 
 **/

import java.util.Iterator;
import java.util.NoSuchElementException;

public class IterableFibonacci implements Iterable<Integer> {
	private int maxIndex;

	/**
	 * Creates a new IterableFibonacci
	 * 
	 * @param maxIndex
	 *            -- the index of the last Fibonacci number returned in this
	 *            sequence
	 * @throws IllegalArgumentException
	 *             if maxIndex < 0
	 **/
	public IterableFibonacci(int maxIndex) {
		if (maxIndex < 0) {
			throw new IllegalArgumentException("Invalid index for Fibonacci"
					+ "sequence: " + maxIndex);
		}
		this.maxIndex = maxIndex;
	}

	/**
	 * sets the maximal index in this Fibonacci sequence
	 * 
	 * @param newMax
	 *            -- the new value of the maximum index in this sequence
	 * @throws IllegalArgumentException
	 *             if newMax < 0
	 **/
	public void setMaxIndex(int newMax) {
		if (newMax < 0) {
			throw new IllegalArgumentException("Invalid index for Fibonacci"
					+ "sequence: " + newMax);
		}
		maxIndex = newMax;
	}

	/**
	 * Returns an iterator that produces the sequence of Fibonacci numbers from
	 * index 0 to the maximum index (inclusive)
	 **/
	public Iterator<Integer> iterator() {
		return new FibonacciIterator();
	}

	private class FibonacciIterator implements Iterator<Integer> {
		// two latest fibonacci numbers:
		private int fib1 = 0;
		private int fib2 = 1;

		/**
		 * @return - true if there are more elements in the sequence, false
		 *         otherwise
		 **/
		public boolean hasNext() {
			return false; // this is just a stub, replace with your code
		}

		/**
		 * @return - the next Fibonacci number in the sequence
		 * @throws -- FILL THIS IN
		 **/
		public Integer next() {
			return 0; // this is just a stub, replace with your code
		}

		/**
		 * method not supported
		 **/
		public void remove() {
			throw new UnsupportedOperationException();
		}
	}
}

Testing code for InterableString and Fibonacci.


import java.util.Iterator;

public class TestIterable {
    public static void main(String [] args) {
	IterableString testString1 = new IterableString("Hi there!");

	System.out.println("Printing a string \"Hi there!\" in a for-each loop");

	for (char c: testString1) {
	    System.out.println(c);
	}

	IterableString testString2 = new IterableString("");

	System.out.println("Printing an empty string in a for-each loop");	
	for (char c: testString2) {
	    System.out.println(c);
	}

	// an iterator that produces up to n-th fibonacci numbers (start at 0)
	IterableFibonacci fibNumbers = new IterableFibonacci(15);

	System.out.println("Fibonacci numbers up to n = 15");
	for (int fib: fibNumbers) {
	    System.out.println(fib);
	}
	
	System.out.println("Fibonacci numbers up to n = 10");
	fibNumbers.setMaxIndex(10);
	for (int fib: fibNumbers) {
	    System.out.println(fib);
	}
	
    }
}

CSci 2101 course web site.

The views and opinions expressed in this page are strictly those of the page author. The contents of this page have not been reviewed or approved by the University of Minnesota.