class Person { String firstName String lastName

String toString() { "$firstName $lastName" }

}

POGOs don’t require access modifiers, because in Groovy attributes are private by default and methods are public by default. The class is public by default, as well. Any property without an access modifier automatically gets a public getter and setter method. If you want to add public or private you can, and either on an attribute will prevent the generation of the associated getter and setter.

GROOVY PROPERTIES In Groovy, property access is done through dynamically generated getter and setter methods.

Here’s a script using the Person class:

Person mrIncredible = new Person() mrIncredible.firstName = 'Robert' mrIncredible.setLastName('Parr') assert 'Robert Parr' ==

"${mrIncredible.firstName} ${mrIncredible.getLastName()}"

Person elastigirl = new Person(firstName: 'Helen', lastName: 'Parr') assert 'Helen Parr' == elastigirl.toString()

The script shows that you also get a default, map-based constructor, so called because it uses the same property:value syntax used by Groovy maps.

This idiom is so common in Groovy that getter and setter methods anywhere in the standard library are typically accessed with the property notation. For example, Calendar.instance is used to invoke the getInstance method on the Calendar class.

Moving now to collections of instances, I’ll start with ranges, then move to lists, and finally look at maps.

B.4 Collections

Since J2SE 1.2, the Java standard library has included the collections framework. The framework defines interfaces for lists, sets, and maps, and provides a small but useful set of implementation classes for each interface, as well as a set of polymorphic utility methods in the class java.util.Collections.

Groovy can use all of these collections but adds a lot:

■Native syntax for lists and maps

■A Range class

■Many additional convenience methods

I’ll present examples of each in this section.

www.it-ebooks.info

B.4.1 Ranges

Ranges are collections in Groovy consisting of two values separated by a pair of dots. Ranges are normally used as parts of other expressions, like loops, but they can be used by themselves.

The class groovy.lang.Range has methods for accessing the boundaries of a range, as well as checking whether it contains a particular element. Here’s a simple example:

Range bothEnds = 5..8 assert bothEnds.contains(5) assert bothEnds.contains(8) assert bothEnds.from == 5 assert bothEnds.to == 8

assert bothEnds == [5, 6, 7, 8]

Using two dots includes the boundaries. To exclude the upper boundary, use a lessthan sign:

Range noUpper = 5..<8 assert noUpper.contains(5) assert !noUpper.contains(8) assert noUpper.from == 5 assert noUpper.to == 7 assert noUpper == [5, 6, 7]

A range of numbers iterates over the contained integers. Other library classes can be used in ranges. Strings go letter by letter:

assert 1..5 == [1,2,3,4,5]

assert 'A'..'E' == ["A","B","C","D","E"]

Dates iterate over the contained days, as shown in the next listing.

Listing B.3 Using dates in a range with Java’s Calendar class

}

assert days == ['Feb 27, 2013', 'Feb 28, 2013', 'Mar 01, 2013']

For all its gifts, even Groovy can’t tame Java’s awkward java.util.Date and java.util

.Calendar classes, but it can make the code for using them a bit simpler. Calendar is an abstract class with the factory method getInstance, so in Groovy I call it by accessing the instance property. The Groovy JDK adds the format method to Date, so it isn’t necessary to separately instantiate SimpleDateFormat.

www.it-ebooks.info

In the listing, after setting the year, month, and day, the Date instance is retrieved by invoking getTime.8 In this case, that’s equivalent to accessing the time property. The dates are used as the boundaries of a range by the each method, which appends each one to a list.

In fact, any class can be made into a range if it includes three features:

■A next() method, for forward iteration

■A previous() method, for backward iteration

■An implementation of the java.util.Comparable interface, for ordering

Here the range is used as the basis of a loop, where the dates are appended to a list.

B.4.2 Lists

Lists in Groovy are the same as lists in Java, except that the syntax is easier and there are some additional methods available. Create a list in Groovy by including values between square brackets:

def teams = ['Red Sox', 'Yankees']

assert teams.class == java.util.ArrayList

The default list is of type java.util.ArrayList. If you prefer to use a LinkedList, instantiate it in the normal way.

Groovy has operator overloading. The Groovy JDK shows that the plus, minus, and left-shift operators have been defined to work with lists:

teams << 'Orioles'

assert teams == ['Red Sox', 'Yankees', 'Orioles'] teams << ['Rays', 'Blue Jays']

assert teams ==

['Red Sox', 'Yankees', 'Orioles', ['Rays', 'Blue Jays']] assert teams.flatten() ==

['Red Sox', 'Yankees', 'Orioles', 'Rays', 'Blue Jays'] assert teams + 'Angels' - 'Orioles' ==

['Red Sox', 'Yankees', ['Rays', 'Blue Jays'], 'Angels']

Accessing elements of a list can be done with array-like syntax. Again, this is done by overriding a method—in this case, the getAt method:

assert teams[0] == 'Red Sox' assert teams[1] == 'Yankees'

assert teams[-1] == ['Rays','Blue Jays']

As shown in figure B.1, access to elements from the left end starts at index 0. Access from the right end starts at index –1. You can use a range in the square brackets, too:

def cities = ['New York', 'Boston', 'Cleveland','Seattle'] assert ['Boston', 'Cleveland'] == cities[1..2]

8 Yes, you read that correctly. You get the date by calling … getTime. Hey, I didn’t write it.

www.it-ebooks.info

Forward

ARRAY-LIKE ACCESS Linear collections support element access through an index from either end, or even using a range.

Groovy adds methods like pop, intersect, and reverse to collections. See the GroovyDocs for details.

There are two ways to apply a function to each element. The spread-dot operator (.*) makes it easy to access a property or apply a method to each element:

assert cities*.size() == [8, 6, 9, 7]

The collect method takes a closure as an argument and applies it to each element of the collection, returning a list with the results. This is similar to the spread-dot operator, but can do more general operations:

def abbrev = cities.collect { city -> city[0..2].toLowerCase() } assert abbrev == ['new', 'bos', 'cle', 'sea']

The word city here used before the arrow is like a dummy argument for a method call. The closure extracts the first three letters of each element of the list and then converts them to lowercase.

One particularly interesting feature of collections is that they support type coercion using the as operator. What does that mean? It’s not terribly difficult to convert a Java list into a set, because there’s a constructor for that purpose. Converting a list into an array, however, involves some awkward, counterintuitive code. Here’s Groovy’s take on the process:

def names = teams as String[] assert names.class == String[]

def set = teams as Set

assert set.class == java.util.HashSet

That was easy.9 A set in Groovy is just like a set in Java, meaning it doesn’t contain duplicates and doesn’t guarantee order.

THE AS OPERATOR Groovy uses the keyword as for many purposes. One of them is type coercion, which converts an instance of one class into an instance of another.

9 I know I say that a lot, but with Groovy I think it a lot, too.

www.it-ebooks.info