GroovyShell

GroovyShell is an interactive command-line application (shell) that allows you to create, run, save, and load Groovy scripts and classes. To start GroovyShell, run groovysh. Figure B-1 illustrates using GroovyShell to execute a simple script.

As you can see, the script prints vishal. Then you see ===> null. As a matter of convention, Groovy always returns the results of methods. In this case, there is no result, so null is returned. GroovyShell contains a built-in help facility that you can use to learn more about the shell. To access it, type help at the prompt. Figure B-2 shows the help listing.

GroovyConsole

GroovyConsole, shown in Figure B-3, is a graphical version of GroovyShell. It is written using SwingBuilder, a Groovy module that makes building a Swing user interface easier.

Figure B-4 shows GroovyConsole with the output detached. You can start GroovyConsole in a number of ways, depending on your environment and how you installed Groovy. The easiest way is to execute GroovyConsole, which is located in the Groovy bin directory.

The console provides the ability to create, save, load, and execute classes and scripts. Some of the nice features of the console are undo/redo and the ability to inspect variables. If you have to choose between using GroovyShell and GroovyConsole, I recommend GroovyConsole.You can also define classes in scripts and use them right away, as illustrated in Listing B-4.

Listing B-4. Defining a Class in the Script

class HelloWorld {
   def hello( name ){
      "Hello ${name}!"
   }
}
def hw = new HelloWorld()
println hw.hello("Vishal")

• The return type of the method hello is not of a specific type, so you use the reserved keyword def.
• The string "Hello" is not a simple java.lang.String. It is, in fact, one of the Groovy features: a GString. These types of strings allow string interpolation, as explained in the next section.

Groovy supports two kinds of strings: regular Java strings and GStrings. A string in Groovy is an instance ofjava.lang.String if it is surrounded by single quotes or if it is surrounded by double or triple quotes with no unescaped dollar sign ($).

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 B-7.

Listing B-7. Single-Quote Strings Do Not Interpret Embedded Expressions

name = "vishal"
s1 = 'hello $name'
println s1
Here is the output:
hello $name

You can nest a double quote in a single quote, as illustrated in Listing B-8.

Listing B-8. Nested Double Quote in Single Quote

s1 = 'hello "vishal"'
println s1

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

Listing B-9. Double-Quoted Strings Interpret Embedded Expressions

def name = "vishal"
s1 = "hello $name"
println s1
Here is the output:
hello vishal

You can nest single quotes in double quotes, as illustrated in Listing B-10.

Listing B-10. 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 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 B-11. 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 B-11. Using Multiline Strings

def name = "Vishal"
def multiLineString = """
Hello, ${name}
This is a multiline string with double quotes
"""
println multiLineString

Hello, Vishal
This is a multiline string with double quotes

Slashy Strings

As mentioned earlier, slashes can be used to define strings. The slashy notation has a 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 B-12 illustrates the difference between using regular quotes and slashes to define a regular expression to match a file system path.

Listing B-12. Using Slashy Strings

def quotedString = 'Hello Vishal'
def slashyString = /Hello Vishal/
println slashyString

Hello Vishal

Listing B-12 defines two variables and assigns them to a directory path. The first variable definition, quotedString, 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.

Multiline Slashy Strings

Slashy strings can also span multiple lines. This is particularly useful for multiline regexes when using the regex freespacing comment style (see Listing B-13).

Listing B-13. 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

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

Let’s take a look at Listing B-13 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.
• Line 5 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 B-14.

Listing B-14. MissingPropertyException in Multiline Slashy String

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

Caught: groovy.lang.MissingPropertyException: No such property: test for class:
hello
groovy.lang.MissingPropertyException: No such property: test for class: hello
at hello.run(hello.groovy:3)

In Listing B-14, there is no such property as test; $test in line 6 is interpreted as an expression, which results in a MissingPropertyException.

Now, let’s look at the code in Listing B-15, specifically line 6.

Listing B-15. Unescaped Dollar Sign in Multiline Slashy String

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

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

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

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

Listing B-16. Using Dollar Slashy String

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

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

Let’s take a look at Listing B-16 in more detail.

• Line 3 defines a dollarSlashy string that includes up to line 8.
• Line 6 has a $test, which has caused a MissingPropertyException in the case of the multiline slashy string in Listing B-14, which you now escape using a $.

Arrays

A Groovy array is a sequence of objects, just like a Java array (see Listing B-17).

Listing B-17. Creating and Using Arrays

1.    def stringArray = new String[3]
2.    stringArray[0] = "A"
3.    stringArray[1] = "B"
4.    stringArray[2] = "C"
5.    println stringArray
6.    println stringArray[0]
7.    stringArray.each { println it}
8.     println stringArray[-1..-3]

• Line 1 creates a string array of size 3.
• Lines 2 to 4 use an index to access the array.
• Line 7 illustrates using the each() method to iterate through the array. The each() method is used to iterate through and apply the closure on every element.
• Line 8 shows something interesting—it uses a range, which will be discussed shortly, to access the array.

[A, B, C]
A
A
B
C
[C, B, A]

Lists

A Groovy list is an ordered collection of objects, just as in Java. It is an implementation of the java.util.List interface. Listing B-18 illustrates how to create a list and common usages.

Listing B-18. Creating and Using Lists

1.    def emptyList = []
2.    def list = ["A"]
3.    list.add "B"
4.    list.add "C"
5.    list.each { println it }
6.    println list[0]
7.    list.set(0, "Vishal")
8.    println list.get(0)
9.     list.remove 2
10.    list.each { println it }

• On line 1, an empty list is created by assigning a property the value of [].
• Lines 2 to 4 create a list with an item already in it and add items to the list.
• Line 5 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.
• Lines 6 illustrates how to use an index to access a list. Lists are zero-based.
• Line 7 shows how to use an index to assign position 0 the value "Vishal".
• Line 8 accesses the list using the get() method.

A
B
C
A
Vishal
Vishal
B

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. Listing B-19 illustrates how to create maps and common usages.

Listing B-19. Creating and Using Maps

1.    def map = ['a':'Value A', 'b':'Value B ']
2.    println map["a"]
3.    println map."a"
4.    println map.a
5.    println map.getAt("b")
6.    println map.get("b")
7.    println map.get("c", "unknown")
8.    println map
9.    map.d = "Value D"
10.    println map.d
11.    map.put('e', 'Value E')
12.    println map.e
13.    map.putAt 'f', 'Value F'
14.    println map.f
15.    map.each { println "Key: ${it.key}, Value: ${it.value}" }
16.    map.values().each { println it }

• Line 1 illustrates how to define a map with multiple entries. When using the square bracket notation, the colon separates the key from the value.
• Lines 2 to 10 show several different techniques for accessing the map.
• Lines 11 to 13 show several different techniques for putting items into the map.

Value A

Value A

Value A

Value B

Value B

unknown

[a:Value A, b:Value B , c:unknown]

Value D

Value E

Value F

Key: a, Value: Value A

Key: b, Value: Value B

Key: c, Value: unknown

Key: d, Value: Value D

Key: e, Value: Value E

Key: f, Value: Value F

Value A

Value B

unknown

Value D

Value E

Value F

Ranges

A range is a list of sequential values. Logically, you can think of it as 1 through 10 or as 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 implement java.lang.Comparable. The objects have next() and previous() methods to facilitate navigating through the range. Listing B-20 illustrates some of the things you can do with ranges.

Listing B-20. Creating and Using Ranges

1.    def numRange = 0..9
2.    numRange.each {print it}
3.    println ""
4.    println numRange.contains(5)
5.    def reverseRange = 9..0
6.    reverseRange.each {print it}
7.    def exclusiveRange = 1..<10
8.    println ""
9.    exclusiveRange.each {print it}
10.    def alphabet = 'a'..'z'
11.    println ""
12.    println alphabet.size()
13.    println alphabet[25]

• Lines 1, 5, 7, and 10 illustrate how to define ranges.
• Line 1 defines an inclusive range of numbers.
• Line 10 defines an inclusive range of lowercase letters.
• Line 7 defines an exclusive list of numbers. The range results in a range of numbers 1 to 9, excluding 10.
• Line 5 creates a range in reverse order, 9 through 0. Frequently, ranges are used for iterating. In Listing B-20, each() was used to iterate over the range. Listing B-21 shows three ways you can use a range to iterate: one in Java and two in Groovy.

0123456789

true

9876543210

123456789

26

z

Listing B-21. Iterating with Ranges

for (i in 0..9) {
println i
}
(0..9).each { i->
println i
}

The each() method is used to iterate through and apply the closure on every element.

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 Groovy set is a java.util.HashSet. If you need a set other than a HashSet, you can create any type of set by instantiating it, as in def TreeSet = new TreeSet(). Listing B-22 illustrates how to create sets and common usages.

Listing B-22. Creating and Using Sets

def  set = ["A", "B" ] as Set
set.add "C"
println set
set.each { println it }
set.remove "B"
set.each { println it }

[A, B, C]

A

B

C

A

C

Creating an empty set is similar to creating an empty list. The difference is the addition of the Set clause. One of the important differences between a list and a set is that a list provides indexed-based access and a set doesn’t.

Understanding Closures

One of the techniques to introduce side effects in a controlled manner is a closure. A closure definition in Groovy follows this syntax:

{ [closure parameters ->] closure body}

where [closure parameters->] is an optional comma-delimited list of arguments, and the closure body can be an expression as well as zero or more Groovy statements. The arguments look similar to a method’s parameter list, and these arguments may be typed or untyped. A Groovy closure is a block of reusable code within curly braces, {}, which can be assigned to a property or a variable or passed as a parameter to a method. A closure is executed only when it is called, not when it is defined. Listing B-25 illustrates this.

Listing B-25. Calling a Closure

1.    def closureVar = {println 'Hello world'}
2.    println "closure is not called yet"
3.    println " "
4.    closureVar.call()

• Line 1: This line has the closure with no parameters and consists of a single println statement. Because there are no parameters, the parameter List and the -> separator are omitted. The closure is referenced by the identifier closureVar.
• Line 4: This line uses the explicit mechanism via the call() method to invoke the closure. You may also use the implicit nameless invocation approach: closureVar(). As shown in the output, the closure prints “Hello world” when it is called in line 4, not when it is defined in line 1.

Here is the output:

closure is not called yet
Hello world

Listing B-26 illustrates the same closure as in Listing B-25 but with the parameter.

Listing B-26. Closure with Parameter

1.    def closureVar = {param -> println "Hello ${param}"}
2.    closureVar.call('world')
3.    closureVar ('implicit world')

• Line 2: This is an explicit call with the actual argument 'world'.
• Line 3: This is an implicit call with the actual argument 'implicit world'.

Hello world
Hello implicit world

As Listing B-27 illustrates, the formal parameters to a closure may be assigned default values.

Listing B-27. Parameters with Default Values

1.    def sayHello= {str1, str2= " default world" -> println "${str1} ${str2}" }
2.    sayHello("Hello", "world")
3.    sayHello("Hello")

• Line 1: The sayHello closure takes two parameters, of which one parameter, str2, has a default value.
• Line 3: Only one actual parameter is provided to the closure, and the default value of the second parameter is used.

Here is the output:

Hello world
Hello default world

Closures always have a return value. The value may be specified via one or more explicit return statements in the closure body, as illustrated in Listing B-28, or as the value of the last executed statement if return is not explicitly specified, as illustrated in Listing B-29.

Listing B-28. Using Return Keyword

def sum = {list -> return list.sum()}
assert sum([2,2]) == 4

Listing B-29. Return Keyword Optional

def sum = {list -> list.sum()}
assert sum([2,2]) == 4

To understand closures, you have to understand the concept of free variables. A closure is formed when the body of a function refers to one or more free variables. Free variables are variables that are not local to the function and are not passed as arguments to the function but are defined in the enclosing scope where the function is defined. Thus, closures refer to variables not listed in their parameter list (free variables). They are “bound” to variables within the scope where they are defined. Listing B-30 illustrates this.

Listing B-30. Free Variables

def myConst = 5
def incByConst = { num -> num + myConst }
assert  incByConst(10) == 15

The runtime “closes over” the free variable (myConst in Listing B-30) so that it is available when the function is executed. That is, the compiler creates a closure that envelops the external context of free variables and binds them.

Implicit Variables

Within a Groovy closure, an implicit variable (it) is defined that has a special meaning. If only one argument is passed to the closure, the arguments list and the -> symbol can be omitted, and the closure will have access to it, which represents that one argument, illustrated in Listing B-31.

Listing B-31. Using it

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

Hello world

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. The developer never has to declare the it variable—like the this parameter within objects, it is implicitly available. If a closure is invoked with zero arguments, then it will be null.

Explicit Declaration of Closure

All closures defined in Groovy are essentially derived from the type Closure. Because groovy.lang is automatically imported, you can refer to Closure as a type within your code. This is an explicit declaration of a closure. The advantage of declaring a closure explicitly is that a nonclosure cannot be inadvertently assigned to such a variable. Listing B-32 illustrates how to declare a closure explicitly.

Listing B-32. Explicit Declaration of a Closure

Closure closure = { 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 B-33 illustrates this.

Listing B-33. Reusing the Method as a Closure

1.    def list = ["A","B","C","D"]
2.    String printElement(String element) {
3.    println element
4.    }
5.    list.each(this.&printElement)

Listing B-33 creates a list of names and iterates through the list to print out the names. In line 5, the method closure operator (.&) causes the method printElement to be accessed as a closure. Here is the output:

A

B

C

D

Passing a Closure as a Parameter

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 (see Listing B-34).

Listing B-34. Passing a Closure As a Parameter

def list = ["A", "B", "C"]
def x = { println it }
list.each(x)

A

B

C

Spread Operator

The spread operator (*.) is a shorthand technique for invoking a method or closure on a collection of objects. Listing B-35 illustrates the usage of the spread operator for iterating over a list.

Listing B-35. Using the Spread Operator

1.    def map = [1:"A", 2:"B", 3:"C", 4:"D"]
2.    def keys = [1, 2, 3, 4]
3.    def values = ["A", "B", "C", "D"]
4.    assert map*.key == keys
5.    assert map*.value == values

Line 4 and line 5 use the spread operator to access keys and values of the map.

Elvis Operator

The Elvis operator (?:)is a shorthand version of the Java ternary operator. For example, b= a ?: 1 could be interpreted as follows:

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

Listing B-36 illustrates using the Java ternary and Elvis operators in Groovy.

Listing B-36. Using the Elvis Operator

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

In both cases, if author.firstName is null, then firstName is set to unknown. The author.firstName fragment of the Elvis operator example is known as the expression. If the expression evaluates to false or null, then the value after the colon is returned.

Safe Navigation/Dereference Operator

The safe navigation/dereference operator (?.) is used to avoid null pointer exceptions. Consider the situation where you have an Author object and you want to print the firstName. If the Author object is null when you access the firstName property, you will get a NullPointerException (see Listing B-37).

Listing B-37. Using the Safe Navigation/Dereference Operator

class Author {
String firstName
String lastName
def printFullName = {
println "${firstName} ${lastName}"
}
}
Author author
println author.firstName

The code in Listing B-37 throws a NullPointerException. In Java, you add a null check this way:

if (author != null) {
println "Author FirstName = ${author.firstName}"
}

Listing B-38 illustrates how to add the null check using the safe navigation/dereference operator in Groovy.

Listing B-38. Using the Safe Navigation/Dereference Operator

class Author {
String firstName
String lastName
def printFullName = {
println "${firstName} ${lastName}"
}
}
Author author
println "Author FirstName = ${author?.firstName}"

Field Operator

Groovy provides a way to bypass the getter and access the underlying field directly. Bypassing the getter and accessing the underlying field is not recommended, however, because it is a violation of encapsulation. Listing B-39 shows an example of using the field operator (.@).

Listing B-39. Using the Field Operator

class Author {
String name
}
def author = new Author(name: "Vishal")
println author.name
printlnauthor.@name

Vishal

Vishal

In this example, the first println uses the getter to access name, and the second println bypasses the getter to access name directly.

Method Closure Operator

The method closure operator (.&)allows the method to be accessed and passed around like a closure (see Listing B-40).

Listing B-40. Using the Method Closure Operator

def list = ["A","B","C"]
list.each { println it }
String printName(String name) {
println name
}
list.each(this.&printName)

A

B

C

A

B

C

This example creates a list of names and iterates through the list to print out the names. A printName() method is created that prints the name parameter. Lastly and the main point of this example, the list is iterated, executing the printName() method as a closure. Using the method closure operator, you are able to expose Java methods as closures.

Diamond Operator

The diamond operator (<>)is introduced in Groovy to avoid the repetition of parameterized types. The parameterized types can be omitted and replaced with pointy brackets, which look like a diamond. Listing B-41 shows a usual verbose way of defining a list.

Listing B-41. A Simple Groovy Script: Hello.groovy

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

Listing B-42 illustrates how to use the diamond operator.

Listing B-42. Using the Diamond Operator

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