Semicolons ; are totally optional and very rarely used, so instead of this Java version:

package com.farenda.tutorials;

import java.time.Clock;

methodCall();

You can write:

package com.farenda.tutorials

import java.time.Clock

methodCall()

The same is with “.class” static, which is very often used in tests:

println(String.class.name)
println(String.name)

Prints the same:

java.lang.String
java.lang.String

The as keyword is used to cast types in Groovy:

def numbers = [1, 2, 3]
println("Type: ${numbers.class.name}")

def casted = numbers as Set
println("Type: ${casted.class.name}")

Gives the following results:

Type: java.util.ArrayList
Type: java.util.LinkedHashSet

By default Groovy imports the following packages and classes:

• java.lang
• java.util
• java.io
• java.net
• groovy.lang
• groovy.util
• java.math.BigInteger
• java.math.BigDecimal

When you need to import two classes that have the same name you can create an alias to prevent conflicts. Or it can be used to shorten name of some very long class name (sometimes generated classes have such names). Example:

// aliases with shorter names:
import javax.xml.parsers.DocumentBuilder as DocBuilder
import javax.xml.parsers.DocumentBuilderFactory as DocFactory

// ... then in code:
def factory = DocFactory.newInstance()
DocBuilder db = factory.newDocumentBuilder()

Groovy has three kinds of strings:

// Simple string are within apostrophes '':
def simpleString = 'String'
println('Like in Java: ' + simpleString)

// GString are within quotes "":
println("GStrings can access vars: ${simpleString.toUpperCase()}")

// Multiline are within triple ':
def longString = '''Multiline
    line
string'''
println(longString)

Note that the indentation in multiline string is preserved!

The above code produces the following text:

Like in Java: String
GStrings can access vars: STRING
Multiline
    line
string

def numbers = [1, 2, 3]
println(numbers)
println("first: ${numbers.first()}")
println("at 0: ${numbers[0]}")
println("at 1: ${numbers[1]}")
println("1st and 2nd: ${numbers[0, 1]}")
println("from 1st to 3nd: ${numbers[0..2]}")

The above code produces the following:

first: 1
at 0: 1
at 1: 2
1st and 2nd: [1, 2]
from 1st to 3nd: [1, 2, 3]

Adding and removing to a list:

numbers.add(4)
println(numbers)

numbers += 5
println(numbers)

numbers += [6, 7]
println(numbers)

numbers << 8 << 9
println(numbers)

// remove range of numbers:
numbers -= (4..8)
println(numbers)

Results:

[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 9]

Sets can be created in very similar way to lists:

// range of numbers as set:
Set numbers = (1..10)
println("type: ${numbers.class.name}")
println("set content: ${numbers}")

def letters = ['a', 'b', 'c'] as Set
println("type: ${letters.class.name}")
println("set content: ${letters}")

Gives:

type: java.util.LinkedHashSet
set content: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
type: java.util.LinkedHashSet
set content: [a, b, c]

def player = 'baz'
// [string, quotes may be omitted, name from var]:
def points = ['foo': 1, bar: 2, (player): 3]
println(points)

points.put('baz', 33)
println(points)

points['foo'] = 11
println("foo has ${points.foo} ponits")

Note that when map key is a string quotes can be omitted! So to use a variable (here player) as a map key we have to surround it with brackets.

The above code produces:

[foo:1, bar:2, baz:3]
[foo:1, bar:2, baz:33]
foo has 11 ponits

def words = ['Some', 'random', 'string', 'for', 'processing']

// 'it' is default name of processed element:
def sizes = words.collectEntries {[(it.toLowerCase()): it.size()]}
println("sizes: ${sizes}")

def shorts = words
        .findAll { it.size() <= 4 }
        .collect { word -> word.toLowerCase() }
        .sort()
println('short words: ' + shorts)

println('has proc? ' + words.any { it.contains('proc')})
println('how many? ' + words.count { it.contains('proc')})

The output is:

sizes: [some:4, random:6, string:6, for:3, processing:10]
short words: [for, some]
has proc? true
how many? 1