Using Script Functions

Like with most scripting languages, you can organize Groovy scripts into blocks of reusable code. In scripts, these blocks are called functions. Listing 2-3 is an example of creating and using a function. It creates a simple function to print a name and calls the function with two different names.

Listing 2-3.  A Script Function:PrintFullName.groovy

def printFullName(firstName, lastName) {
println "${firstName} ${lastName}"
}
printFullName('Luke', 'SkyWalker')
printFullName('Darth', 'Vader')

This example defines the printFullName function, which takes two parameters. Next, the function is invoked twice: once to print Luke Skywalker and again to print Darth Vader.

Compiling Groovy

In the previous examples, we let Groovy compile the script on the fly. Like with Java, you can compile Groovy to Java byte code. Listing 2-4 illustrates compiling the Groovy script from Listing 2-1.

Listing 2-4.  Compiling Groovy with groovyc

groovyc Hello.groovy

As you might expect, compiling Hello. Groovy results in Hello.class. Because Groovy compiles to Java bytecode, you can use the Java command line to execute it.

Listing 2-5.  Running the Groovy Program Using Java

java -cp %GROOVY_HOME%/embeddable/groovy-all-2.0.0.jar;. Hello "Luke Skywalker"

Here is the output:

Hello Luke Skywalker

Being able to run the Groovy program using Java proves it—Groovy is Java. If you look at Listing 2-5, you’ll see that the only thing special required to run the Groovy compilers to include groovy-all-<version>.jar on the classpath.

The Groovy compiler is a joint compiler. It can compile Groovy and Java code at the same time. The joint compiler first became available in Groovy 1.5 through a generous donation by JetBrains, the makers of IntelliJ IDEA. The joint compiler allows you to compile Groovy and Java files with a single compile statement. Listings 2-6 and 2-7 are a Groovy file and a Java file, respectively, to demonstrate joint compilation.

Listing 2-6.  A Sample Groovy File: Name.groovy

class Name
{
String firstName
String toString() { return "Hello ${firstName}, Java calling Groovy" }
}

Listing 2-7.  A Sample Java File:SayHello.java

public class SayHello
{
    public static void main(String args[ ])
    {
        Name name = new Name();
        name.setFirstName( args[0] );
        System.out.println( name.toString() );
    }
}

The Java class, SayHello, instantiates the Groovy class Name and sets the firstName property to a value passed in on the command Line. Listing 2-8 illustrates compiling and executing the programs.

Listing 2-8.  Joint Compile and Execute

groovyc *.groovy *.java
java -cp %GROOVY_HOME%/embeddable/groovy-all-2.0.0.jar;. SayHello "Luke"

Here is the output:

Hello Luke, Java calling Groovy

Compiling the Groovy and Java classes is accomplished by telling groovy to compile files matching the file pattern ending in .groovy and .java. You run the program in the same way that you run any other Java program—just include groovy-all-<version>.jar in the classpath.

Running Groovy

You can run Groovy scripts and classes through the command Line, Groovy Shell, or Groovy Console. Let’s look at each technique.

Power Asserts

Groovy’s assert keyword just checks that the expression passed to it is true or false. If false, it just tells you the expression was false, and gives the value of variables used in the expression, but nothing more. With Power Asserts, the output of the assert provides a visual representation of the value of each sub expression of the expression being asserted, as illustrated in Listing 2-11.

Listing 2-11.  Power Assert Feature

assert new File('HelloWorld.txt') == new File('Hello.txt')

Caught: Assertion failed:

assert new File<'HelloWorld.txt'> == new File<'Hello.txt'>
       ¦                           ¦ ¦
       HelloWorld.txt              ¦ Hello.txt
                                   false
Assertion failed:

assert new File<'HelloWorld.txt'> == new File<'Hello.txt'>
       ¦                           ¦ ¦
       HelloWorld.txt              ¦ Hello.txt
                                   false
         at Hello.run<Hello.groovy:2>

Assertions are very handy and one of the cornerstones of good testing. They also do a great job of clarifying intentions. You will see assertions in many of the examples throughout this book.

GStrings

GStrings are an instance of groovy.lang.GString and allow placeholders to be included in the text. GStrings are not a subclass of String because the String class is final and can’t be extended. A GString is just like a normal string, but it allows the embedding of variables within it using ${..}. The curly braces are only required if the embedded variable is a placeholder for an expression.

Groovy supports a concept found in many other languages such as Perl and Ruby called string interpolation. String interpolation is the ability to substitute an expression or variable within a string. If you have experience with Unix shell scripts, Ruby, or Perl, this should look familiar. Java doesn’t support string interpolation. You must manually concatenate the values.

Listing 2-12 is an example of the type of code you need to write in Java.

Listing 2-12.  Building Strings with Java

String name = "Jim";
String helloName = "Hello " + name;
System.out.println(helloName);

Listing 2-13.  String Interpolation in Groovy/GString

1. str1= "Jim"
2. str2 = "Hello "
3. println "$str2$str1"

In Line 3, curly braces are not used because curly braces are only required if the embedded variable is a placeholder for an expression.

When Groovy sees a string defined with double quotes or slashes and an embedded expression, Groovy constructs an org.codehaus.groovy.runtime.GStringImpl instead of a java.lang.String. When the GString is accessed, the expression is evaluated. Notice that you can include any valid Groovy expression inside the ${} notation; this includes method calls or variable names.

Single Line Strings

Single line strings can be single quoted or double quoted. A string enclosed in single quotes is taken literally. Strings defined with single quotes do not interpret the embedded expressions, as illustrated in Listing 2-14.

Listing 2-14.  Single Quote String does not Interpret Embedded Expressions

name = "vishal"
s1 = 'hello $name'
println s1

Here is the output:

hello $name

Listing 2-15.  Nested Double Quote in Single Quote

s1 = 'hello "vishal"'
println s1

Here is the output:

hello "vishal"

Strings defined using double quotes will interpret embedded expressions within the string, as illustrated in Listing 2-16.

Listing 2-16.  Double Quote Strings Interpret Embedded Expressions

def name = "vishal"
s1 = "hello $name"
println s1

Here is the output:

hello vishal

Listing 2-17.  Nested Single Quote in Double Quote

s1 = "hello 'vishal'"
println s1

Here is the output:

hello 'vishal'

Multiline Strings

Groovy supports strings that span multiple lines. A multiline string is defined by using three double quotes or three single quotes.

Multiline string support is very useful for creating templates or embedded documents (such as XML templates, SQL statements, HTML, and so on). For example, you could use a multiline string and string interpolation to build the body of an e-mail message, as shown in Listing 2-18. String interpolation with multiline strings works in the same way as it does with regular strings: Multiline strings created with double quotes evaluate expressions, and single-quoted strings don’t.

Listing 2-18.  Using Multiline Strings

def name = "Jim"
def multiLineQuote = """
Hello, ${name}
This is a multiline string with double quotes
"""
println multiLineQuote
println multiLineQuote.class.name
def multiLineSingleQuote = '''
Hello, ${name}
This is a multiline string with single quotes
'''
println multiLineSingleQuote
println multiLineSingleQuote.class.name

Running the code in Listing 2-18 results in the following output:

Hello, Jim
This is a multiline string with double quotes

org.codehaus.groovy.runtime.GStringImpl

Hello, ${name}
This is a multiline string with single quotes

Java.lang.String

Slashy Strings

As mentioned earlier, slashes can be used to define strings. The slashy notation has a very nice benefit: Additional backslashes are not needed to escape special characters. The only exception is escaping a backslash: /. The slashy notation can be helpful when creating a regular expression requiring a backslash or a path. Listing 2-19 illustrates the difference between using regular quotes and slashes to define a regular expression to match a file system path.

Listing 2-19.  Using Slashy Strings

def winpathQuoted='C:\windows\system32'
def winpathSlashy=/C:windowssystem32/
println winpathSlashy // C:windowssystem32
assert winpathSlashy ==∼ '\w{1}:\\.+\\.+'
assert winpathSlashy ==∼ /w{1}:\.+\.+/

Listing 2-19 defines two variables and assigns them to a directory path. The first variable definition, winpathQuoted, uses the single-quote notation to define a string. Using the single-quote notation requires that the embedded backslash be escaped using an additional backslash. The first assert statement, which tests the regular expression defined using single quotes, also requires the addition of an extra backslash to escape a backslash.

Notice how using the slashy notation doesn’t require the additional backslashes.

Clearly, it is easier to write and read winpath Slashy, and the second regular expression is easier to write and read as well. Regular expressions and the ==∼ operator will be covered in more detail in the “Regular Expressions” section later in this chapter.

Multiline Slashy Strings

Slashy strings can also span multiple lines. This is particularly useful for multiline regexs when using the regex free-spacing comment style.

Listing 2-20.  Using Multiline Slashy Strings

1. def name = "vishal"
2. def path= "c:/groovy"
3. def multilineSlashy = /
4.     Hello $name
5.     path= $path
6.     dollar = $
7.     path = c:/groovy
8.     /
9. println multilineSlashy

Here is the output:

Hello vishal
path= c:/groovy
dollar = $
path = c:/groovy

Let’s take a look at Listing 2-20 in a little more detail:

• Line 1 defines a variable, name, and assigns the value “vishal” to it.
• Line 2 defines a variable, path, and assigns the value “c:/groovy” to it.
• Line 3 defines a variable, multilineSlashy, and assigns a multiline string to it that includes up to Line 8, between the slashes.
• Line 4 has an expression, $name, that is evaluated to vishal, as shown in the output.
• Line5 has an expression, $path, that is evaluated to c:/groovy, as shown in the output.
• Line 6 has a $ sign but it is not an expression, so it is displayed in the output.
• Line 7 has a slash, which needs to be escaped.

Dollar Slashy Strings

In multiline slashy strings, a slash still needs to be escaped. Moreover, in multiline slashy strings, an unescaped dollar sign that is not an expression results in a MissingPropertyException, as illustrated in Listing 2-21.

Listing 2-21.  MissingPropertyException in Multiline Slashy String

1. def name = "vishal"
2. def path= "c:/groovy"
3. 
4. def multilineSlashy = /
5.     Hello $name
6.     path= $path
7.     dollar = $test
8.     path = c:/groovy
9.     /
10. println multilineSlashy

Caught: groovy.lang.MissingPropertyException: No such property: test for class:
Hello
groovy.lang.MissingProperyException: No such property: test for class: Hello
                  at Hello.run<Hello.groovy:4>

In Listing 2-21, there is no such property as test; $test in Line 7 is interpreted as an expression, which results in a MissingPropertyException.

Now, let us look at the code in the Listing 2-22, specifically Line 7.

Listing 2-22.  Unescaped Dollar Sign in Multiline Slashy String

1. def name = "vishal"
2. def path= "c:/groovy"
3. 
4. def multilineSlashy = /
5.     Hello $name
6.     path= $path
7.     dollar = $ test
8.     path = c:/groovy
9.     
10.     /
11.     
12. println multilineSlashy

This time Groovy does not interpret $ test in Line 7 as an expression, as there is an empty space between $ and test, and renders the output as follows:

Hello vishal
path= c:/groovy
dollar = $ test
path = c:/groovy

With dollar slashy string, you are no longer required to escape slash with a preceding backslash (multiline slashy strings require the slash to be escaped) and you can use $$ to escape a $ or $/ to escape a slash if needed, as illustrated in Listing 2-23.

Listing 2-23.  Using Dollar Slashy String

1. def name = "vishal"
2. def path= "c:/groovy"
3. 
4. def dollarSlashy = $/
5.     Hello $name
6.     path= $path
7.     dollar = $$test // escaping $test with a $
8.     path = c:/groovy
9.     /$
10. println dollarSlashy

Hello vishal
path= c:/groovy
dollar = $test
path = c:/groovy

Let’s take a look at Listing 2-23 in more detail:

• Line 4 defines a dollarSlashy string that includes up to Line 9.
• Line 7 has a $test, which had caused a MissingPropertyException in the case of the multiline slashy string in Listing 2-21, which we now escape using a $.

Groovy Regular Expression Operators

Groovy leverages Java’s regular expression support and makes it easier through Groovy’s

String support. Groovy also adds three convenience operators:

• The match operator (==∼)
• The find operator (=∼)
• The pattern operator (∼string)

1. assert "abc" ==∼ 'abc'
2. assert "abc" ==∼ /abc/
3. assert "abcabc" ==∼ /abc/ // Fails – not an exact match
4. assert "abc" ==∼ /^a.c/ // Starts with a, 1 char, ends with c
5. assert "abc" ==∼ /^a../ // Starts with a, 2 chars
6. assert "abc" ==∼ /.*c$/ // One or more chars end with c
7. assert "abc" ==∼ ".*c$" // Slashy string is better

1. def winpath=/C:windowssystem32somedir/
2. def matcher = winpath =∼ /(w{1}):\(w+)\(w+)\(w+)/
3. println matcher
4. println matcher[0] // ["C:windowssystem32somedir", "C", "windows",
5. // "system32", "somedir"]
6. println matcher[0][1] // C
7. def newPath = matcher.replaceFirst('/etc/bin/')
8. println newPath // /etc/bin

java.util.regex.Matcher[pattern=(w{1}):\(w+)\(w+)\(w+) region=0,27
lastmatch=]
["C:windowssystem32somedir", "C", "windows", "system32", "somedir"]
C
/etc/bin/

1. def saying = """Now is the time for all good men (and women) to come to the aid
2. of their country"""
3. def pattern = ∼/(w+en)/
4. def matcher = pattern.matcher(saying)
5. def count = matcher.getCount()
6. println "Matches = ${count}"
7. for(i in 0..<count) {
8. println matcher[i]
9. }

Matches = 2
["men", "men"]
["women", "women"]

Common Uses of Regular Expressions

By now, you are starting to get an idea of how regular expressions work. Now let’s see how they can be applied in real-world scenarios. It is common for web applications to allow the user to enter personal information such as a telephone number. Two common tasks are to check that the phone number is a valid format and to parse the phone number into the individual parts. Listing 2-27 is an example of using the match operator to validate a phone number.

Listing 2-27.  Validating a Phone Number

def phoneValidation = /^[01]?s*[(.-]?(d{3})[).-]?s*(d{3})[.-](d{4})$/
assert '(800)555-1212' ==∼ phoneValidation
assert '1(800) 555-1212' ==∼ phoneValidation
assert '1-800-555-1212' ==∼ phoneValidation
assert '1.800.555.1212' ==∼ phoneValidation

In this example, you see the same phone number in four different valid formats. The regular expression to validate the phone number format is assigned to the variable phoneValidation. The match operator is used to validate the phone numbers by applying the regular expression to the phone number. If the phone number is valid, the match operator returns true.

Another common task is parsing a phone number so that the values can be put into a domain class. Listing 2-28 illustrates parsing the phone number into the individual parts and loading it in the domain class.

Listing 2-28.  Parsing the Phone Number

class Phone {
String areaCode
String exchange
String local
}
def phoneStr = '(800)555-1212'
def phoneRegex = ∼/^[01]?s*[(.-]?(d{3})[).-]?s*(d{3})[.-](d{4})$/
def matcher = phonePattern.matcher(phoneStr)
def phone = new Phone(
areaCode: matcher[0][1],
exchange: matcher[0][2],
local: matcher[0][3])
println "Original Phone Number: ${phoneStr}"
println """Parsed Phone Number

	Area Code = ${phone.areaCode}

	Exchange = ${phone.exchange}

	Local = ${phone.local}"""

In this example, the Phone object, the phone number to parse (phone1), and the phone regular expression pattern (phoneRegex) are defined. Next, the phone pattern is applied to the phone number to be parsed. The pattern is defined with groups, which allows the regular expression to be used to parse the phone number into the individual parts. The construction of the Phone object illustrates accessing the individual parts using the second index. Lastly, we print out the phone number to prove that the parsing worked.

Arrays

A Groovy array is a sequence of objects, just like a Java array. Groovy makes working with arrays a little easier, but you have the same limitations as with Java arrays.

Listing 2-29.  Creating and Using Arrays

1.  def stringArray = new String[3]
2.  println stringArray.size()
3.  stringArray[0] = "Chris"
4.  println stringArray // {"Chris", null, null}
5.  stringArray[1] = "Joseph"
6.  stringArray[2] = "Jim"
7.  println stringArray // {"Chris", "Joseph", "Jim"}
8.  println stringArray[1] // Joseph
9.  stringArray.each { println it} // Chris, Joseph, Jim
10. println stringArray[-1..-3] // ["Jim", "Joseph", "Chris"]

Line 1 creates a string array of size 3. Lines 3–8 use an index to access the array. Line9 illustrates using the each() method to iterate through the array. That deserves a second look. Yes, the each() method is available on the array, which is very convenient. The each() method is used to iterate through and apply the closure on every element. A closure always has at least one argument, which will be available within the body of the closure via the implicit parameter it if no explicit parameters are defined. Both the each() method and the it variable are discussed in detail in the Closures section of this chapter. Line 10 also shows something interesting—it uses a range, which will be discussed shortly, to access the array. In this case, the example goes one step further and shows accessing the array from left to right.

Lists

A Groovy list is an ordered collection of objects, just as in Java. It is an implementation of the java.util.List interface. In the course of building Grails applications, it is common to see lists returned from the controllers and services. Listing 2-30 illustrates creating a list and common usages.

Listing 2-30.  Creating and Using Lists

1.  def emptyList = []
2.  println emptyList.class.name // java.util.ArrayList
3.  println emptyList.size // 0
4.
5.  def list = ["Chris"] // List with one item in it
6.  // Add items to the list
7.  list.add "Joseph" // Notice the optional () missing
8.  list << "Jim" // Notice the overloaded left-shift operator
9.  println list.size // 3
10.
11. // Iterate over the list
12. list.each { println it } // Chris Joseph Jim
13.
14. // Access items in the list
15. println list[1] // Joseph // Indexed access
16. list[0] = "Christopher"
17. println list.get(0) // Christopher
18.
19. list.set(0, "Chris") // Set the 0 item to Chris
20. println list.get(0) // Chris
21.
22. list.remove 2
23. list-= "Joseph" // Overloaded - operator
24. list.each { println it } // Chris
25.
26. list.add "Joseph"
27. list+="Jim" // Overloaded + operator
28. list.each { println it } // Chris Joseph Jim
29. println list[-1] // Jim

On Line 1 of Listing 2-30, an empty list is created by assigning a property the value of [] . Line 2 prints out the list’s class name so that you can see that it is a java.util.ArrayList. Line 3 prints the list’s size, which is 0. Lines 5–9 create a list with an item already in it and show two ways to add items to the list.

Line 12 iterates over the list, invoking the closure to print out the contents. The each() method provides the ability to iterate over all elements in the list, invoking the closure on each element. This is an example of using a closure as a parameter to a method. Lines 15–17 illustrate using an index to access a list. Lists are zero-based. Line 15 shows accessing the second item in the list. Line 16 shows using an index to assign position() the value “Christopher”. Line 17 accesses the list using the get()  method. Lines19–20 use the set() method to assign the first position in the list and then print it out. Lines 22–24 remove items from the list using the remove() method and the minus operator. Lines 26–28 add items to the list using the add() method and the plus operator. Line 29 is interesting—it uses the index value -1. Using a negative index value causes the list to be accessed in the opposite order, or from last to first.

Maps

A Groovy map is an unordered collection of key/value pairs, where the key is unique, just as in Java. It is an implementation of java.util.Map. By default, unless you specify otherwise, a Groovy map is a java.util.LinkedHashMap. If you are familiar with LinkedHashMap maps, you know that they are ordered by insert. If you need a map other than a LinkedHashMap, you can create any type of map by instantiating it; for example, def aTreeMap = new TreeMap(). In general, we encourage you to think of it as a regular map.

Listing 2-31 illustrates creating maps and common usages.

Listing 2-31.  Creating and Using Maps

1.  def emptyMap = [:]
2.  // map.class returns null, use getClass()
3.  println emptyMap.getClass().name //java.util.LinkedHashMap
4.  println emptyMap.size() // 0
5.
6.  def todos = ['a':'Write the map section', 'b':'Write the set section']
7.  println todos.size() // 2
8.  println todos["a"] // Write the map section
9.  println todos."a" // Write the map section
10. println todos.a // Write the map section
11. println todos.getAt("b") // Write the set section
12. println todos.get("b") // Write the set section
13. println todos.get("c", "unknown") // unknown, Notice "c" wasn't defined
14. // and now it is
15. println todos // ["a":"Write the map section", "b":"Write the set section",
16. // "c":"unknown"]
17.
18. todos.d = "Write the ranges section"
19. println todos.d // Write the ranges section
20. todos.put('e', 'Write the strings section')
21. println todos.e // Write the strings section
22. todos.putAt 'f', 'Write the closure section' // Notice () are optional
23. println todos.f // Write the closure section
24. todos[null] = 'Nothing Set' // Using null as a key
25. println todos[null] // Nothing set
26.
27. // Print each key/value pair on a separate Line
28. // Note: it is an implicit iterator
29. todos.each { println "Key: ${it.key}, Value: ${it.value}" }
30. // Print each key/value pair on a separate Line with index
31. todos.eachWithIndex { it, i -> println "${i} Key: ${it.key},Value: ${it.value}" }
33. // Print the value set
34. todos.values().each { println it }

In Line 1, an empty map is created by assigning a property the value [:]. Compare the creation of an empty list to the creation of an empty map. An empty list is created using the value []; an empty map is created using the value [:]. You can see from Line 2 that the map is implemented as a java.util.LinkedHashMap.

Line 6 illustrates defining a map with multiple entries. When using the square bracket notation, the colon separates the key from the value. Line 6 is [key1: value1,key2 : value2].

Lines 8–16 show several different techniques for accessing the map. The most interesting is Line 10. It shows using the key as a property to the map. You can use this technique to read an item from the map and put an item into the map.

Lines 18–25 show several different techniques for putting items into the map. You can see that they mirror the techniques used on lines 8–16.

Lines 29, 31, 32, and 34 illustrate iterating. Line 29 iterates over the map to print the key and value. Lines 31 and 32 iterate with an index. Line 34 iterates over the map values.

Ranges

A range is a list of sequential values. Logically, you can think of it as 1 through 10 or a through z. As a matter of fact, the declaration of a range is exactly that: 1..10, or 'a'.'z'. A range is a list of any objects that implements java.lang.Comparable. The objects have next() and previous() methods to facilitate navigating through the range. This means that with a bit of work, it is possible to use your own Groovy objects within a range. Listing 2-32 illustrates some of things you can do with ranges.

Listing 2-32.  Creating and Using Ranges

1.  def numRange = 0..9
2.  println numRange.size() // 10
3.  numRange.each {print it} // 0123456789
4.  println ""
5.  println numRange.contains(5) // true
6.
7.  def alphaRange = 'a'..'z'
8.  println alphaRange.size() // 26
9.  println alphaRange[1] // b
10.
11. def exclusiveRange = 1..<10
12. println exclusiveRange.size() // 9
13. exclusiveRange.each {print it} // 123456789
14. println ""
15. println exclusiveRange.contains(10) // false
16.
17. def reverseRange = 9..0
18. reverseRange.each {print it} // 9876543210

Lines 1, 7, 11, and 17 illustrate defining ranges. Line 1 defines an inclusive range of numbers. Line 7 defines an inclusive range of lowercase letters. Line 11 defines an exclusive list of numbers. The range results in a range of numbers 1–9, excluding 10. Line 17creates a range in reverse order, 9 through 0.Frequently, ranges are used for iterating. In Listing 2-32, each() was used to iterate over the range. Listing 2-33 shows three ways you could use a range to iterate: one Java and two Groovy.

Listing 2-33.  Iterating with Ranges

1.  println "Java style for loop"
2.  for(int i=0;i<=9;i++) {
3.  println i
4.  }
5.
6.  println "Groovy style for loop"
7.  for (i in 0..9) {
8.  println i
9.  }
10.
11. println "Groovy range loop"
12. (0..9).each { i->
13. println i
14. }

Listing 2-33 starts off by showing a classic Java style for loop. Lines 7–9 are an example of the same loop using the Groovy style for loop. The for loop syntax is discussed in detail in the next section. Lines 12–14 illustrate yet another technique for looping, by using a range and the each() method. The each() method is used to iterate through and apply the closure on every element. A closure always has at least one argument, which will be available within the body of the closure via the implicit parameter it if no explicit parameters are defined. Both the each() method and it variable are discussed in detail in Closures section of this chapter.

Sets

A Groovy set is an unordered collection of objects, with no duplicates, just as in Java. It is an implementation of java.util.Set. By default, unless you specify otherwise, a Groovyset is a java.util.HashSet. If you need a set other than a HashSet, you can create any type of set by instantiating it; for example, def aTreeSet = new TreeSet(). In general, we encourage you to think of it as a regular set. Listing 2-34 illustrates creating sets and common usages.

Listing 2-34.  Creating and Using Sets

1.  def emptySet = [] as Set
2.  println emptySet.class.name // java.util.HashSet
3.  println emptySet.size() // 0
4.
5.  def list = ["Chris", "Chris" ]
6.  def set = ["Chris", "Chris" ] as Set
7.  println "List Size: ${list.size()} Set Size: ${set.size()}" // List Size: 2 Set
    Size: 1
8.  set.add "Joseph"
9.  set << "Jim"
10. println set.size() // 3
11. println set // ["Chris", "Jim", "Joseph"]
12.
13. // Iterate over the set
14. set.each { println it }
15.
16. set.remove 2
17. set-= "Joseph" // Overloaded - operator
18. set.each { println it } // Chris
19. set+= "Joseph"
20. set+= "Jim"
21. set.each { println it } // Chris Joseph Jim
22.
23. // Convert a set to a list
24. list = set as List
25. println list.class.name // java.util.ArrayList
26. println set.asList().class.name // java.util.ArrayList
27. println set.toList().class.name // java.util.ArrayList

Creating an empty set is similar to creating an empty list. The difference is the addition of the as Set clause. Lines 5–7 illustrate that a list allows duplicates and a set doesn’t. Lines 8–21 shouldn’t be any surprise. One of the important differences between a list and a set is that a list provides indexed-based access and a set doesn’t. Lines 24 and 26 show two different techniques to convert a set into a list.

Groovy Truth

In Groovy, any expression can be evaluated, unlike in Java where only boolean variables and expressions can evaluate to true or false. In Groovy truth, null Object references evaluate to false. Non-empty collections, arrays, and maps, strings with non-zero length, and non-zero numbers will all evaluate to true. This is very helpful, especially with strings and collections, as illustrated in Listing 2-35.

Listing 2-35.  Null Check for Collections and Strings in Java

if (collection != null && !collection.isEmpty()) { ... } // collection
if (str != null && str.length() > 0) { ... }// string

Listing 2-36.  Null Check for Collections and Strings in Groovy

if (collection) { ... } // collection
if (str) { ... }// string

In Groovy, it is possible to provide a method for coercion to boolean in your own classes. Listing 2-37 illustrates  how Groovy offers the ability to coerce SomeClass instances to true or false, using the implementation of the booleanasBoolean() method.

Listing 2-37.  Using asBoolean() Method

class SomeClass{
boolean value
boolean asBoolean() { value }
}
assert new Test(value: true)
assert !new Test(value: false)

Logical Branching

Groovy has three conditionals: the if statement, the ternary operator, and the switch statement. The if statement and ternary operator are the same as in Java, though Groovy enhances the ternary operator with the Elvis operator. The Elvis operator is discussed in Chapter 3. The switch statement is more powerful in Groovy than in Java, in that the switch accepts any kind of object (unlike Java), as illustrated in Listing 2-38.

Listing 2-38.  Using switch

def x = 3.14
def result = ""

switch ( x ) {
    case "foo": result = "String"

    case [4, 5, 6 ]:
        result = "List"
        break

    case 12..30:
        result = "Range"
        break

    case Integer:
        result = "Integer"
        break

    case Number:
        result = "Number"
        break

    default:
        result = "Default"
}

assert result == "Number"

Looping

In addition to supporting Java for loops, Groovy also provides a much simpler for loop that works with any kind of array collection, as illustrated in Listing 2-39.

Listing 2-39.  Using the for Loop

for (i in 'Hello')Iterate over a string
    println i

for (i in 0..10)   //Iterate over a range
    println i

for (i in [1,2,3,4]) //Iterate over a list
    println i

authors = [1:'Vishal', 2:'Jim', 3: 'Chris', 4:'Joseph']

for (entry in map) //Iterate over a map
  println entry.key + ' ' + entry.value

Listing 2-39 shows the for loop for iterating over string, range, list, and map using the in operator as a shortcut for the contains method in a collection.

Exception Handling

Exception handling in Groovy is the same as in Java. Just as in Java, you can specify a try-catch-finally sequence of blocks, or just try-catch, or just try-finally. In addition to that, in Groovy, declarations of exceptions in the method signature are optional, even for checked exceptions, and a type declaration is optional in the catch expression.

In Groovy it is possible for try/catch/finally blocks to return a value when they are the last expression in a method or a closure. There is no need to explicitly use the return keyword inside these constructs, as long as they are the latest expression in the block of code. If an exception is thrown in the try block, the last expression in the catch block is returned instead. finally, blocks don’t return any value, as illustrated in Listing 2-40.

Listing 2-40.  Returning Value from try/catch/finally

def method(bool) {
    try {
        if (bool) throw new Exception("foo")
        1
    } catch(e) {
        2
    } finally {
        3
    }
}

assert method(false) == 1
assert method(true) == 2

In Groovy, it is also possible to define several exceptions to be catch and treated by the same catch block with the multi-catch block, as illustrated in Listing 2-41.

Listing 2-41.  Multi-catch Block

try{
   /* ... */
}catch(IOException | NullPointerException e) {
   /* one block to handle 2 exceptions*/
}

Implicit Variables

Within a Groovy closure, several variables are defined that have special meaning:

def clos = {println "Hello ${it}"}
clos.call('world')

Hello world

1. class Class1{
2.   def closure = {
3.     println "---in closure---"
4.     println this.class.name
5.     println owner.class.name
6.     println delegate.class.name
7.     def nestedClosure = {
8.     println "---in nestedClosure---"
9.       println this.class.name
10.       println owner.class.name
11.       println delegate.class.name
12.     }
13.     nestedClosure()
14.    }
15. }
16. 
17. def clos = new Class1().closure
18. clos()
19. println ""
20. println "===changing the delegate==="
21. clos.delegate = this
22. clos()
23. println ""
24. 
25. def closure2 = {
26.    println "--- closure outside the class(in the script)---"
27.    println this.class.name
28.      println delegate.class.name
29.      println owner.class.name
30. 
31. }
32. 
33. closure2()

---in   closure---
Class1
Class1
Class1
---in   nestedClosure---
Class1
Class1$_closure1
Class1$_closure1
===changing  the  delegate===
---in   closure---
Class1
Class1
Hello
---in  nestedClosure---
Class1
Class1$_closure1
Class1$_closure1
---  closure   outside  the  class<in  the  script>---
Hello
Hello
Hello

Explicit Declaration of Closure

All closures defined in Groovy are essentially derived from the type Closure. Because groovy.lang is automatically imported, we can refer to Closure as a type within our code. This is explicit declaration of closure. The advantage of declaring closure explicitly is that a non-closure cannot be inadvertently assigned to such variable.

Listing 2-52.  Explicit Declaration of Closure

Closure clos = { println it }

Reusing the Method as a Closure

Groovy provides the method closure operator (.&) for reusing the method as a closure. The method closure operator allows the method to be accessed and passed around like a closure. Listing 2-53 illustrates this.

Listing 2-53.  Reusing the Method as a Closure

1. def list = ["Vishal","Chris","Joseph","Jim"]
2. list.each { println it }
3. String printName(String name) {
4. println name
5. }
6. list.each(this.&printName)

Listing 2-53 creates a list of names and iterates through the list to print out the names. In Line 6, the method closure operator (.&) causes the method printName to be accessed as a closure.

Here is the output:

Vishal
Chris
Joseph
Jim
Vishal
Chris
Joseph
Jim

A closure is an object. You can pass closures around just like any other objects. A common example is iterating over a collection using a closure.

Listing 2-54.  Passing a Closure As a Parameter

def list = ["Chris", "Joseph", "Jim"]
def sayHello = { println it }
list.each(sayHello)

Notice that sayHello is a property whose value is a closure. It is passed to the each() method so that as each() iterates over the list, the sayHello closure is invoked.

Closures and Collection

Lists, Maps, and Ranges include a number of methods (GDK methods) that have a closure parameter, which makes it effortless to iterate over the elements of the collection or range. We will discuss any, collect, each, every, and find methods.

boolean any(Closure closure)

def anyElement= [1, 2, 3, 4].any {element -> element > 2}
assert anyElement == true

List collect(Closure closure)

def doubled = [1, 2, 3, 4].collect {element -> return 2*element}
assert doubled == [2,4,6,8]

void each(Closure closure)

[1, 2, 3].each {println it}

1
2
3

boolean every(Closure closure)

def allElements1 = [1, 2, 3, 4].every {element -> element > 1}
assert allElements1 == false

def allElements2 = [2, 3, 4, 5].every {element -> element > 1}
assert allElements2 == true

Object find(Closure closure)

def foundElement = [1, 2, 3, 4].find {element -> element > 2}
assert foundElement == 3

Closures as Map Keys and Values

It’s possible to put closures in a map, both as keys and values. You can use a closure as a key and as a value and call that closure as if it were a method on the map. However, when putting it into the map, you must escape it by enclosing it in parentheses. When accessing the value of the closure in the map, you must use get(key) or map[key], as map. Key will treat key as a string.

Listing 2-60.  Using Closure as Key and Value

1. key1 = { println "closure as key" }
2. map1 = [ (key1): 100 ]
3. 
4. println  map1.get(key1)
5. println  map1[key1]
6. 
7. map1 = [ key1: { println "closure as value" } ]
8. map1.key1()

The output is:

100
100

closure as value

• In Line 1, a closure is used as a key: key1.
• In Line 2, key1 is stored in the map and the value is 100.
• Line 4 prints the value stored in the map.
• Line 5 is another technique to retrieve the value.
• In Line 7, a closure is used as a value.
• Line 8 calls the closure stored as the value and prints “closure as value”.

Currying Closure

Currying is the technique of transforming a function that takes multiple arguments in such a way that it can be called as a chain of functions, each with a single argument. In Groovy, you can use the curry() method to form curried closures.

Listing 2-61.  Using Closure

1. def add= { x, y -> return x + y }
2. assert add(1,2) == 3

• Line 1 defines an add closure that takes two parameters and adds them.
• Line 2 replaces the formal parameter x with the value 1, replaces y with the value 2, and asserts that the sum is 3.

Now consider that instead of providing actual values to both formal parameters (x and y), we only provide a value to one of the parameters. The definition of the new closure with one actual value looks like this:

                 newAdd= { 1, y -> return 1 + y }

We just defined a new closure (newAdd) by providing actual value 1 to a formal parameter (x) of the closure add. This is what curry() method does for us; for example, we can define the closure newAdd by calling curry() on closure add, and provide the actual value 1 to one of the formal parameters, like so:

                 newAdd = add.curry(1)

The definition of this closure newAdd is still the same; for example, newAdd= {1,y -> 1+y}. We can fix the value of y in the same way by calling curry() on the closure newAdd; for example, newAdd.curry().

Listing 2-62.  Currying Closure

1. def add= { x, y -> return x + y }
2. def newAdd = closure.curry(1)
3. assert "${ newAdd(2)}" == 3

Closure Trampoline

As we discussed earlier, in functional programming, because of the immutability of variables, it is not possible to have loop counters that change through a loop on each pass. The pure functional way of implementing such loop counter is through recursion.

Recursion, in a large measure, plays a crucial role in functional programming. That said there are two latent problems associated with recursion: the performance penalty of repetitive function calls and the probability of stack overflow.  Performance penalty associated with repetitive function calls can be addressed with memorization, as discussed next.  Stack overflow can be avoided by converting the recursive calls into a loop called trampoline.

Listing 2-63.  Stack Overflow Error in Recursion

1. def factorial
2. factorial={n,BigInteger acc=1->
3.                 n == 1 ? acc:
4. factorial(n-1, n*acc)
5. }
6. factorial(1000)

A trampoline is a loop that works through a list of functions, calling each one in turn. In Groovy, a trampoline is formed by adding . trampoline() to a closure declaration, as illustrated in Listing 2-64.

Listing 2-64.  Using Trampoline

1. def factorial
2.
3. factorial={n, BigInteger acc=1->
4. 
5. n == 1 ? acc:
6. factorial.trampoline(n-1, n*acc)
7. }.trampoline()
8. 
9. factorial(1000)

Closure Memoization

Performance penalty associated with repetitive function calls in recursion can be addressed with memoization.

Memoization is a technique used to perform internal optimizations by caching previously computed values. Caching introduces side effects, in otherwise side effect free, pure functional programming, as the state of the cache is modified.

Listing 2-65.  Using Memoization

1. closure = {param1, param2 ->  sleep(100); param1 + param2 }
2. 
3. memoizedClosure = closure.memoize()
4. 
5. def testTime(param1, param2) {  begin = System.currentTimeMillis()
6.                                 memoizedClosure(param1, param2)
7.                                 timeElapsed = System.currentTimeMillis()
8.                                 println "param1 = $param1, param2 =
  $param2   time :${timeElapsed - begin } ms."
9. }
10. 
11. testTime(1, 2)
12. testTime(3, 4)
13. testTime(1, 2)

The output is:

param1 = 1,  param2 = 2    time :153 ms.
param1 = 3,  param2 = 4    time :100 ms.
Param1 = 1,  param2 = 2    time :0 ms.

Listing 2-65  illustrates  memoization in action. In Line 3, closure is memoized. That is why the testTime closure call in Line 13 with the same parameters as in Line 11 takes 0 ms.

Operator Overloading

Operator overloading has been around for some time, but absent from Java. Operator overloading was omitted from Java because of the bad experiences it brought with its usage in C++. Groovy embraces operator overloading and makes it easy to define and use. An overloaded operator executes a method on object. Groovy has predefined the relationship between the overloaded operator and the object method. Table 2-2 lists the Groovy operators and their corresponding methods. When an overloaded operator is encountered, the corresponding method is invoked.

At first glance, you may not see the benefits of operator overloading. Groovy uses operator overloading to create shortcuts that make Java friendlier. For example, adding an object to a list in Java looks like this: myList.add(someObject). The corresponding Groovy way of adding an object to a list is myList << someObject. Operator overloading isn’t limited to the predefined instances that Groovy supplies; you can add operator overloading to your Groovy classes by implementing the corresponding method.

Specialized Operators

Groovy includes many of the standard operators found in other programming languages, as well as operators that are specific to Groovy that enable it to be so powerful.

1. def map = [1:"Vishal", 2:"Chris", 3:"Joseph", 4:"Jim"]
2. def keys = [1, 2, 3, 4]
3. def values = ["Vishal", "Chris", "Joseph", "Jim"]
4. assert map*.key == keys
5. assert map*.value == values

if(a != 0)
        b = a
else
    b = 1

def firstName = user.firstName == null ? "unknown" : user.firstName // Java ternary
def firstName2 = user.firstName ?: "unknown" // Groovy Elvis

class User {
    String firstName
    String lastName
    def printFullName = {
        println "${firstName} ${lastName}"
    }
}
User user
println user.firstName

if (user != null) {
    println "Java FirstName = ${user.firstName}"
}

class User {
    String firstName
    String lastName
    def printFullName = {
        println "${firstName} ${lastName}"
    }
}
User user
println "Groovy FirstName = ${user?.firstName}"

class Todo {
    String name
    def getName() {
        println "Getting Name"
        name
    }
}
def todo = new Todo(name: "Jim")
println todo.name
println todo.@name

Getting Name
Jim
Jim

def list = ["Chris","Joseph","Jim"]
// each takes a closure
list.each { println it }
String printName(String name) {
    println name
}
// & causes the method to be accessed as a closure
list.each(this.&printName)

Chris
Joseph
Jim
Chris
Joseph
Jim

List<List<String>> list1 = new ArrayList<List<String>>()

List<List<String>> list1 = new ArrayList<>()