DZone Snippets: iterator code

Treating first/last loop iterations differently

Zarkonnen (David Stark) — Wed, 25 Jul 2007 10:10:01 GMT

Sometimes, you need to iterate over a list of items and treat the first and last element differently from the rest. This tends to produce really messy code, which can be avoided using the following snippet.

Imagine you have a list of Kittens, and you want to print out a summary of them, saying "My kittens are called Bob, James, John, and Ally." You need to treat the first and last element of the list differently from the rest, lest you end up with superfluous commas in the text. You also need to deal with the cases of there being only one kitten, or no kittens at all.

To do this, you can avail yourself of a Counter class that keeps track of where you are in the iteration:



String kittenDesc = "I have no kittens.";

Counter kc = new Counter(kittens);

for (Kitten k : kittens) switch(kc.next()) {

	case one:   kittenDesc =  "My kitten is called " + k.getName() + "."; break;

	case first: kittenDesc =  "My kittens are called " + k.getName();     break;

	case item:  kittenDesc += ", " + k.getName();                         break;

	case last:  kittenDesc += " and " + k.getName() + ".";                break;

}



package com.zarkonnen.util;



import java.util.Collection;



/**

 * Used for keeping track of where you are in a collection/array being iterated over. Use by

 * initialising with the collection/array before the loop and embedding a switch on the next() Mode

 * value into the loop.

 *

 * LICENCE: This code is licenced under a BSD licence. Feel free to alter and redistribute.

 *

 * @author David Stark, http://www.zarkonnen.com

 * @version 1.0 (2007-07-11)

 */

public class Counter {

	/**

	 * An enumeration of modes identifying where in the collection/array we are.

	 */

	public enum Where {

		/** The only element of an array/collection of size 1. */ one,

		/** The first element. */                                 first,

		/** The last element of the array/collection. */          last,

		/** Any other element somewhere in the middle. */         item

	}

	

	private int size;

	private int nextIndex = 0;

	

	/**

	 * @param c A collection to keep track of. If its size changes between now and the

	 * iteration, strange things will happen.

	 */

	public Counter(Collection c) {

		size = c.size();

	}

	

	/**

	 * @param a An array to keep track of. If its size changes between now and the iteration,

	 * strange things will happen.

	 */

	public Counter(Object[] a) {

		size = a.length;

	}

	

	/**

	 * @return A Where enum value for where in the array/collection we now are:

	 * 

	 * one at the only element of an array/collection of size 1

	 * first at the first element

	 * last at the last element

	 * item at any other element

	 * 

	 */

	public Where next() {

		return size == 1         ? Where.one   :

		       nextIndex++ == 0  ? Where.first :

		       nextIndex == size ? Where.last  :

		                           Where.item  ;

	}

	

	/**

	 * @return Which index of the array/collection we're currently at.

	 */

	public int index() {

		return nextIndex == 0 ? 0 : nextIndex - 1;

	}

}

range() in Java

tutego (Chrsitian Ullenboom) — Tue, 24 Apr 2007 13:20:16 GMT

A range is a very handy feature of programing languages like Python.

* range( 10 ) -> 0 1 2 3 4 5 6 7 8 9
* range( 5, 10 ) -> 5 6 7 8 9
* range( 0, 10, 3 ) -> 0 3 6 9
* range( '0', '9' ) -> 012345678

With an extended for loop it is possible to use such a feature too:



/*

 * This project is made available under the terms of the BSD license, more information can be found at

 * http://www.opensource.org/licenses/bsd-license.html

 *

 * Copyright (c) 2007. Christian Ullenboom (http://www.tutego.com/) and contributors. All rights reserved.

 */

package com.tutego;



import java.util.Iterator;



/**

 * Class that generates immutable sequences (ranges) as Iterable

 * objects. A range represents a start (0 if not given), an stop (mandatory) and

 * an optional step (1 by default). The start value is included in the range,

 * the stop value is exclusive. Every range is handled by an Iterable

 * which can by used in an extended for loop.

 * 

 * 
 * for ( int i : range( 0, 10, 3 ) )

 *   System.out.print( i + " " ); // 0 3 6 9

 * 

 * 

 * @author Christian Ullenboom (tutego)

 * @version 1.0

 */

public class Range

{

  public static Iterable range( final int start, final int stop, final int step )

  {

    if ( step <= 0 )

      throw new IllegalArgumentException( "step > 0 isrequired!" );



    return new Iterable()

    {

      public Iterator iterator()

      {

        return new Iterator()

        {

          private int counter = start;



          public boolean hasNext()

          {

            return counter < stop;

          }



          public Integer next()

          {

            try

            {

              return counter;

            }

            finally { counter += step; }

          }



          public void remove() { }

        };

      }

    };

  }



  public static Iterable range( final int start, final int stop )

  {

    return range( start, stop, 1 );

  }



  public static Iterable range( final int stop )

  {

    return range( 0, stop, 1 );

  }

}

This is an example:



package com.tutego;



import static com.tutego.Range.range;



public class RangeDemo

{

  public static void main( String[] args )

  {

    for ( int i : range( 10 ) )

      System.out.print( i + " " );



    System.out.println();



    for ( int i : range( 5, 10 ) )

      System.out.print( i + " " );



    System.out.println();



    for ( int i : range( 0, 10, 3 ) )

      System.out.print( i + " " );



    System.out.println();



    for ( int i : range( '0', '9' ) )

      System.out.print( (char) i  );



    System.out.println();



    String[] a = { "Mary", "had", "a", "little", "lamb" };

    for ( int i : range(a.length ) )

      System.out.printf( "%d %s%n", i, a[i] );

  }

}

Handy Iterable for a range of Integers

asgeirn (Asgeir S. Nilsen) — Tue, 10 Apr 2007 14:39:26 GMT

Looping a specific number of times produces code a bit too verbose in Java. The JDK5 enhanced for statement is a handy improvement, but you still have to fall back to the traditional for statement if you want to repeat a loop, say, 10 times.

Not with this implementation of Iterable. You can use it like this:



for (int i : new Range(100))

    System.out.printf("I have said this %d times. Read dzone.com!%n", i);



class Range implements Iterable {

    

    private final Integer stop;

    

    public Range(int stop) {

        this.stop = stop;

    }



    public Iterator iterator() {

        return new Iterator() {

            

            private Integer counter = 0;



            public boolean hasNext() {

                return (counter != stop);

            }



            public Integer next() {

                if (counter == stop)

                    throw new NoSuchElementException();

                return ++counter;

            }



            public void remove() {

            }};

    }

    

}

Flattening iterator

DRMacIver (David R. MacIver) — Wed, 14 Feb 2007 19:02:51 GMT

A trivial utility class for iterating through a collection of objects in a 'flat' manner, descending into any collections (in this case defined as iterators, iterables or arrays, rather than elements of the Collection interface ) it finds and iterating through their elements. This preserves order, so {a, b, {c, d, {e}}} will be iterated through as a, b, c, d, e.

It's not very complicated, but the implementation amused me so I thought I'd share it.



package playground.library.functional.iterator;



import java.lang.reflect.Array;

import java.util.Arrays;

import java.util.Iterator;

import java.util.NoSuchElementException;

import java.util.Stack;



/**

 * An iterator that 'flattens out' collections, iterators, arrays, etc. 

 *

 * That is it will iterate out their contents in order, descending into any 

 * iterators, iterables or arrays provided to it.

 *

 * An example (not valid Java for brevity - some type declarations are ommitted):

 *

 * new FlattingIterator({1, 2, 3}, {{1, 2}, {3}}, new ArrayList({1, 2, 3}))

 *

 * Will iterate through the sequence 1, 2, 3, 1, 2, 3, 1, 2, 3.

 *

 * Note that this implements a non-generic version of the Iterator interface so

 * may be cast appropriately - it's very hard to give this class an appropriate 

 * generic type.

 *

 * @author david

 */

public class FlatteningIterator implements Iterator

{

    // Marker object. This is never exposed outside this class, so can be guaranteed

    // to be != anything else. We use it to indicate an absense of any other object.

    private final Object blank = new Object();

    

    /* This stack stores all the iterators found so far. The head of the stack is

     * the iterator which we are currently progressing through */

    private final Stack> iterators = new Stack>();

    

    // Storage field for the next element to be returned. blank when the next element

    // is currently unknown.

    private Object next = blank;

        

    public FlatteningIterator(Object... objects){

        this.iterators.push(Arrays.asList(objects).iterator());}

    

    public void remove(){

        /* Not implemented */}

    

    private void moveToNext(){

        if ((next == blank) && !this.iterators.empty() ) {

            if (!iterators.peek().hasNext()){

                iterators.pop();

                moveToNext();}

                else{

                    final Object next = iterators.peek().next();

                    if (next instanceof Iterator){

                      iterators.push((Iterator)next);

                      moveToNext();}

                    else if (next instanceof Iterable){

                       iterators.push(((Iterable)next).iterator());

                       moveToNext();}

                    else if (next instanceof Array){

                        iterators.push(Arrays.asList((Array)next).iterator());

                        moveToNext();}

                    else this.next = next;}}}

    

    /**

     * Returns the next element in our iteration, throwing a NoSuchElementException

     * if none is found. 

     */

    public Object next() {

        moveToNext();

        

        if (this.next == blank) throw new NoSuchElementException();

        else{

            Object next = this.next;

            this.next = blank;

            return next;

        }}

    

    /**

     * Returns if there are any objects left to iterate over. This method 

     * can change the internal state of the object when it is called, but repeated

     * calls to it will not have any additional side effects.

     */

    public boolean hasNext(){

        moveToNext();

        return (this.next != blank);}    

}

Iterator to return N items at-a-time

korakot (Korakot Chaovavanich) — Thu, 15 Sep 2005 00:46:50 GMT

Copied from paul cannon's recipe here



def group(iterator, count):

    itr = iter(iterator)

    while True:

        yield tuple([itr.next() for i in range(count)])

After the above definition, you can use it very easily.



>>> list(group([0, 1, 2, 3, 4, 5], 2))

[(0, 1), (2, 3), (4, 5)]



>>> dataset = ['Nausori', 5, 'Namadi', 10, 'Suva', 3]

>>> for place, value in group(dataset, 2):

...   print '%s: %s' % (place, value)

... 

Nausori: 5

Namadi: 10

Suva: 3

The above code is somewhat simplified.
See the recipe for full discussion.