Groovy Each Iterator with Peek-ahead at Next Collection Value
2010/06/15Groovy closures combined with iterators make it simple to create our own enhanced iterators that let us process a collection how we want to.
I write my own custom iterators all the time and name them something descriptive. This makes the code much more readable. Rather than trying to decipher what a for loop is trying to do, we wrap up all of that iteration logic into a meaningful name and we cleanly separate that iteration from the processing that we’re doing with each element.
This kind of design is a core concept in Uncle Bob’s Clean Code, one of my favorite programming books in the last few years.
This example iterates over a collection and calls the passed in closure until we hit a value greater than 5.
def eachUntilGreaterThanFive = { collection, closure -> for ( value in collection ) { if ( value > 5 ) break closure(value) } } def a = [1, 2, 3, 4, 5, 6, 7] eachUntilGreaterThanFive(a) { println it }
prints:
1 2 3 4 5
This code makes it obvious what the iterator is doing (looping till we hit a condition) as well as what will happen with each element iterated over (print it out).
For a real life example, I had a need to iterate over a list of values and where I needed both the current object as well as a peek at the next object in the list.
Doing this is Java is a bit of a pain, but groovy makes it easy to write and (hopefully) to read, we can also add it directly onto the Collection metaClass so that it’s available for all of our Collection instances:
Collection.metaClass.eachWithPeek = { closure -> def last = null delegate?.each { current -> if (last) closure(last, current) last = current } if (last) closure(last, null) }
These test cases show that as we iterate through the collection, we can see the current item and peek at the next one (if any). If the collection is empty, we don’t execute the closure it, and if we’re at the end of the list there isn’t anything to peek at:
[].eachWithPeek { current, peek -> assert false // shouldn't get here, nothing to iterate through } [1].eachWithPeek { current, peek -> assert current == 1 assert peek == null // only 1 element, nothing to peek at } def results = [] [1, 2, 3, 4, 5].eachWithPeek { current, peek -> results << [current, peek] } assert results == [[1, 2], [2, 3], [3, 4], [4, 5], [5, null]]